07jdk7u21原生利用链

JDK7u21

反序列化的关键

• 在于找到可以动态方法执行的代码：例如CC链中的Transformer，CB链中的PropertyUtils#getProperty
  

JDK7u21中动态方法执行的点，AnnotationInvocationHandler#equalsImpl中的hisValue = memberMethod.invoke(o)。

1. private Boolean equalsImpl(Object o) {
2.         if (o == this)
3.             return true;
5.         if (!type.isInstance(o))
6.             return false;
7.         for (Method memberMethod : getMemberMethods()) {
8.             String member = memberMethod.getName();
9.             Object ourValue = memberValues.get(member);
10.             Object hisValue = null;
11.             AnnotationInvocationHandler hisHandler = asOneOfUs(o);
12.             if (hisHandler != null) {
13.                 hisValue = hisHandler.memberValues.get(member);
14.             } else {
15.                 try {
16.                     hisValue = memberMethod.invoke(o);
17.                 } catch (InvocationTargetException e) {
18.                     return false;
19.                 } catch (IllegalAccessException e) {
20.                     throw new AssertionError(e);
21.                 }
22.             }
23.             if (!memberValueEquals(ourValue, hisValue))
24.                 return false;
25.         }
26.         return true;
27.     }
29. private Method[] getMemberMethods() {
30.         if (memberMethods == null) {
31.             memberMethods = AccessController.doPrivileged(
32.                 new PrivilegedAction<Method[]>() {
33.                     public Method[] run() {
34.                         final Method[] mm = type.getDeclaredMethods();
35.                         validateAnnotationMethods(mm);
36.                         AccessibleObject.setAccessible(mm, true);
37.                         return mm;
38.                     }
39.                 });
40.         }
41.         return memberMethods;
42.     }

复制代码

AnnotationInvocationHandler#equalsImpl是一个私有方法，仅在AnnotationInvocationHandler#invoke中被调用，它遍历执行了this.type的所有方法，如果这里的this.type为TemplatesImpl，那就可以实现任意代码执行。

1. public Object invoke(Object proxy, Method method, Object[] args) {
2.         String member = method.getName();
3.         Class<?>[] paramTypes = method.getParameterTypes();
5.         // Handle Object and Annotation methods
6.         if (member.equals("equals") && paramTypes.length == 1 &&
7.             paramTypes[0] == Object.class)
8.             return equalsImpl(args[0]);
9.         if (paramTypes.length != 0)
10.             throw new AssertionError("Too many parameters for an annotation method");
12.         switch(member) {
13.         case "toString":
14.             return toStringImpl();
15.         case "hashCode":
16.             return hashCodeImpl();
17.         case "annotationType":
18.             return type;
19.         }
21.         // Handle annotation member accessors
22.         Object result = memberValues.get(member);
24.         if (result == null)
25.             throw new IncompleteAnnotationException(type, member);
27.         if (result instanceof ExceptionProxy)
28.             throw ((ExceptionProxy) result).generateException();
30.         if (result.getClass().isArray() && Array.getLength(result) != 0)
31.             result = cloneArray(result);
33.         return result;
34.     }

复制代码

前面找到动态代码执行的关键后，构造链条的关键即在于如何调用equalsImpl和equalsImpl如何举行任意代码执行。
如何调用equalsImpl

由于AnnotationInvocationHandler实现了接口InvocationHandler，这里很明显可以采用CC1中用到的动态署理调用AnnotationInvocationHandler#invoke，但是注意到invoke的代码逻辑，我们署理的对象，必须是调用名为equals且只有一个Object类型的参数时，才会触发equalsImpl。
找到equals调用链

equals方法通常用于比力两个对象是否是同一引用，一个常见场景是集合set，集合是不允许重复对象的，所以在添加对象局势必涉及到比力操纵。

1. // HashSet#readObject
2. private void readObject(java.io.ObjectInputStream s)
3.         throws java.io.IOException, ClassNotFoundException {
4.         // Read in any hidden serialization magic
5.         s.defaultReadObject();
7.         // Read capacity and verify non-negative.
8.         int capacity = s.readInt();
9.         if (capacity < 0) {
10.             throw new InvalidObjectException("Illegal capacity: " +
11.                                              capacity);
12.         }
14.         // Read load factor and verify positive and non NaN.
15.         float loadFactor = s.readFloat();
16.         if (loadFactor <= 0 || Float.isNaN(loadFactor)) {
17.             throw new InvalidObjectException("Illegal load factor: " +
18.                                              loadFactor);
19.         }
21.         // Read size and verify non-negative.
22.         int size = s.readInt();
23.         if (size < 0) {
24.             throw new InvalidObjectException("Illegal size: " +
25.                                              size);
26.         }
28.         // Set the capacity according to the size and load factor ensuring that
29.         // the HashMap is at least 25% full but clamping to maximum capacity.
30.         capacity = (int) Math.min(size * Math.min(1 / loadFactor, 4.0f),
31.                 HashMap.MAXIMUM_CAPACITY);
33.         // Create backing HashMap
34.         map = (((HashSet<?>)this) instanceof LinkedHashSet ?
35.                new LinkedHashMap<E,Object>(capacity, loadFactor) :
36.                new HashMap<E,Object>(capacity, loadFactor));
38.         // Read in all elements in the proper order.
39.         for (int i=0; i<size; i++) {
40.             @SuppressWarnings("unchecked")
41.                 E e = (E) s.readObject();
42.             map.put(e, PRESENT);
43.         }
44.     }

复制代码

这里k.hashCode()作为产生hash的唯一变量，由于TemplateImpl的hashCode方法是一个Native方法，我们欠好追溯，因此选择看一下署理对象的hashCode，而proxy.hashCode() 仍旧会调用到 AnnotationInvocationHandler#invoke ，进而调用到 AnnotationInvocationHandler#hashCodeImpl

1. // jdk8u21 hashmap
2. public V put(K key, V value) {
3.         if (key == null)
4.             return putForNullKey(value);
5.         int hash = hash(key);
6.         int i = indexFor(hash, table.length);
7.         for (Entry<K,V> e = table[i]; e != null; e = e.next) {
8.             Object k;
9.             if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
10.                 V oldValue = e.value;
11.                 e.value = value;
12.                 e.recordAccess(this);
13.                 return oldValue;
14.             }
15.         }
17.         modCount++;
18.         addEntry(hash, key, value, i);
19.         return null;
20.     }

复制代码

这里代码逻辑很简答，遍历 memberValues 这个Map中的每个key和value，计算每个 (127 * key.hashCode()) ^ value.hashCode() 并求和。
我们如何构造一个和恶意TemplateImpl的hash值一致的署理对象呢，JDK7u21中使用了一个非常巧妙的方法：

• 当 memberValues 中只有一个key和一个value时，该哈希简化成 (127 * key.hashCode()) ^ value.hashCode()
  
• 当 key.hashCode() 等于0时，任何数异或0的结果照旧他自己，所以该哈希简化成 value.hashCode() 。
  
• 当 value 就是TemplateImpl对象时，这两个哈希就酿成完全相等
  

1. if (e.hash == hash && ((k = e.key) == key || key.equals(k)))

复制代码

可以通过一个简单的爆破程序找到一个hash值为0的字符串
POC代码

1. final int hash(Object k) {
2.         int h = 0;
3.             // 是否启用备用hash算法，一般情况下不启用，可忽略
4.         if (useAltHashing) {
5.             if (k instanceof String) {
6.                 return sun.misc.Hashing.stringHash32((String) k);
7.             }
8.             h = hashSeed;
9.         }
11.         h ^= k.hashCode();
13.         // This function ensures that hashCodes that differ only by
14.         // constant multiples at each bit position have a bounded
15.         // number of collisions (approximately 8 at default load factor).
16.         h ^= (h >>> 20) ^ (h >>> 12);
17.         return h ^ (h >>> 7) ^ (h >>> 4);
18.     }

复制代码

注意这里代码添加的顺序

1. private int hashCodeImpl() {
2.         int result = 0;
3.         for (Map.Entry<String, Object> e : memberValues.entrySet()) {
4.             result += (127 * e.getKey().hashCode()) ^
5.                 memberValueHashCode(e.getValue());
6.         }
7.         return result;
8.     }
10. private static int memberValueHashCode(Object value) {
11.         Class<?> type = value.getClass();
12.         if (!type.isArray())    // primitive, string, class, enum const,
13.                                 // or annotation
14.             return value.hashCode();
16.         // ......
17.     }

复制代码

在hash表中，同一hash地址对应的链表中的元素是有先后顺序的，我们要包管key.equals(k)的k是恶意TemplatesImpl，key是署理对象，而不是反过来。
poc代码中的两个问题

有两个小问题,InvocationHandler tempHandler = (InvocationHandler) handlerConstructor.newInstance(Templates.class, map);  1.为啥可以传递Templates.class进去,要求不是继续或实现了Annotation 接口的class吗 2.第一个参数传Templates.class是由于这个接口的实现类只有TemplatesImpl 这一个吗,后面type遍历也能调方法

解答：
<blockquote>
遐想到cc1，我当时也有这个疑问。后面看了一下，大概是和不同jdk版本的AnnotationInvocationHandler实现不同，我看了jdk7u21和jdk8u66这两个版本的构造函数是不一样的，7u21中AnnotationInvocationHandler(Class var1, Map var2) {    this.type = var1;    this.memberValues = var2; } 8u66中AnnotationInvocationHandler(Class type, Map memberValues) {    Class[] superInterfaces = type.getInterfaces();    if (!type.isAnnotation() ||        superInterfaces.length != 1 ||        superInterfaces[0] != java.lang.annotation.Annotation.class)        throw new AnnotationFormatError("Attempt to create proxy for a non-annotation type.");    this.type = type;    this.memberValues = memberValues; } 这里Class