java

关注公众号 jb51net

关闭
首页 > 软件编程 > java > Java反射与Fastjson 反序列化

Java反射与Fastjson的危险反序列化详解

作者:ZywOo

在 Java 中,Computer.class是一个引用,它表示了 Computer 的字节码对象(Class对象),这个对象被广泛应用于反射、序列化等操作中,那么为什么 parseObject 需要这个引用呢,带着这个问题我们一起通过本文学习下吧

Preface

前文中,我们介绍了 Java 的基础语法和特性和 fastjson 的基础用法,本文我们将深入学习fastjson的危险反序列化以及预期相关的 Java 概念。

什么是Java反射?

在前文中,我们有一行代码 Computer macBookPro = JSON.parseObject(preReceive,Computer.class);

这行代码是什么意思呢?看起来好像就是我们声明了一个名为 macBookProComputer 类,它由 fastjson 的 parseObject 方法将 preReceive 反序列化而来,但 Computer.class 是什么呢?

在 Java 中,Computer.class是一个引用,它表示了 Computer 的字节码对象(Class对象),这个对象被广泛应用于反射、序列化等操作中。那么为什么 parseObject 需要这个引用呢?首先 fastjson 是不了解类中的情况的,因此它需要一个方法来动态的获得类中的属性,那么 Java 的反射机制提供了这个功能。

Java reflect demo

我们先看一个 Java 反射的 Demo。

​​​​​​​
package org.example;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Parameter;
public class JavaReflectDemo {
    public static void main(String[] args){
        // 获取Car类的Class对象,用于后续的反射操作
        Class<?> temp = Car.class;
        // 获得Car类的所有属性与方法和构造方法
        Field[] fields = temp.getDeclaredFields();
        Method[] methods = temp.getDeclaredMethods();
        Constructor<?>[] constructors = temp.getDeclaredConstructors();
        // 通过循环遍历获得类属性
        for (Field field : fields){
            System.out.println("Field: " + field.getName());
        }
        // 通过循环遍历获得方法名
        for (Method method : methods ) {
            System.out.println("Methods: " + method.getName());
        }
        // 通过双循环获得类的构造方法及其方法所需要的参数的数据类型
        for (Constructor<?> constructor : constructors) {
            System.out.println("Constructor:" + constructor.getName());
            Class<?>[] constructorParameterType = constructor.getParameterTypes();
            for (Class<?> parameterType : constructorParameterType) {
                System.out.println("Parameter type is:" + parameterType.getName());
            }
        }
        // 通过反射调用类方法
    }
    public static class Car{
        private int carLength;
        public String carName;
        private int carPrice = 50000;
        public Car(int carLength, String carName,int carPrice){
            this.carLength = carLength;
            this.carName = carName;
            this.carPrice = carPrice;
        }
        private void CarAnnounce() {
            System.out.println("China Car! Best Car!");
            System.out.println("The Car Price is " + this.carPrice);
            System.out.println("The Car Length is " + this.carLength);
        }
        private void CarType(){
            System.out.println("This function is still under development!");
        }
    }
}

​​​​​​​反射调用类变量

上述代码中,我们有一个公共静态类 Car ,其中包含了私有和公共方法和属性,在主函数中通过反射获取了类的属性和方法以及构造方法,我们逐行分析代码。

运行结果如下。

反射调用类方法

简要将Demo中的代码修改如下。

// 通过循环遍历获得方法名
for (Method method : methods) {
	// 直接调用类的静态方法
	if (method.getName().equals("CarType")) {
   		method.invoke(null);
	}
    // 通过类的实例调用类方法
    if (method.getName().equals("CarAnnounce")){
    	Car tempCar = new Car(1000,"Richard's car");
        method.invoke(tempCar);
        // 通过反射获得类字段,并修改字段值重新调用方法
        Field field = temp.getDeclaredField("carPrice");
        field.setAccessible(true);
        field.set(tempCar, 99999);
        method.invoke(tempCar);
    }
	System.out.println("Methods: " + method.getName());
}

我们可以通过反射直接调用类的方法,method.invoke(类的实例, 参数, 多个参数用逗号隔开),若是调用静态方法可以传递 null 代替类的实例,但如果调用的方法需要参数,我们需要严格得按照方法传入对应的参数。

我们还可以通过反射修改 private 属性,例如 Demo 中的 carPrice。运行结果如下。

我们将 carLength 使用 final 修饰符进行修饰,此时直接修改 carLength 会报错。如下图。

但通过反射我们可以修改 final 修饰符修饰后的属性。代码如下。

Field field2 = temp.getDeclaredField("carLength");
field2.setAccessible(true);
Field modifiers = field2.getClass().getDeclaredField("modifiers");
modifiers.setAccessible(true);
modifiers.setInt(field2, field2.getModifiers() & ~Modifier.FINAL);
field2.set(tempCar, 7777);
method.invoke(tempCar);

我们来重点关注其中的操作,我们首先获取 carLengthField 对象,并设置其为可读写的权限。

其次获取该对象的 modifiers 对象,它表示 carLength 被哪些修饰符所修饰。

重点是modifiers.setInt(field2, field2.getModifiers() & ~Modifier.FINAL) 我们逐步进行解析:

整段代码的执行结果如下。

反射执行命令

在 Java 中,有一个类叫做 java.lang.Runtime ,这个类有一个 exec 方法可以用于执行本地命令。一般情况下我们使用如下的方法执行命令。我们通过Runtime.getRuntime()方法获得实例,并创建新的Process对象,用于执行命令。

Runtime类是Java中的一个特殊类,它负责提供Java应用程序与运行时环境(Java虚拟机)的交互接口。它被设计为单例模式,确保整个应用程序中只有一个Runtime实例。这种设计决定了Runtime类无法被直接实例化。

package org.example;
public class ExecuteCommandDemo {
    public static void main(String[] args){
        try {
            // 创建Runtime对象
            Runtime temp = Runtime.getRuntime();
            Process process = temp.exec("calc.exe");
            // 等待命令执行完毕
            process.waitFor();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

而我们同样可以通过反射来执行命令。

首先获取Runtime类对象以便后续的反射操作,再从Runtime类中获取getRuntime方法,通过执行getRuntime方法获取实例,再从类中找到 exec 方法,但由于 exec 具有很多重载版本,我们指定使用接收字符串作为参数的方法。最后通过调用 exec 方法,执行命令。

package org.example;
import java.lang.reflect.Method;
public class ExecuteCommandDemo {
    public static void main(String[] args){
        try {
            Class <?> reflectExec = Class.forName("java.lang.Runtime");
            Method getruntimeMethod = reflectExec.getMethod("getRuntime");
            Object runtimeInstance = getruntimeMethod.invoke(null);
            Method execMethod = reflectExec.getMethod("exec", String.class);
            Process process = (Process) execMethod.invoke(runtimeInstance, "calc.exe");
            // 等待命令执行完毕
            process.waitFor();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

​​​​​​​Fastjson的危险反序列化

@type 是fastjson中的一个特殊注解,它告诉 fastjson 应该将 JSON 字符串转换成哪个 Java 类。这很容易出现安全问题

我们来看下面这段代码,我们定义了一串json字符串,想要通过@type注解来将json字符串转化为java.lang.Runtime对象,但是 fastjson在 1.2.24 后默认禁用 autoType 的白名单设置,在默认情况下我们不能任意的将json字符串转化为指定的java类。

但通过 ParserConfig.getGlobalInstance().addAccept("java.lang") 我们可以在白名单中添加 java.lang 类。

后续的代码就是通过反序列化将其转换为对象(这里的Object.class是为了接收转换后的任意对象),再强制转换为Runtime对象,转换完成后就和正常调用java.lang.Runtime执行命令相同了。

package org.example;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.parser.ParserConfig;
public class FastjsonDangerousDeserialization {
    public static void main(String[] args) throws Exception{
        String json = "{\"@type\":\"java.lang.Runtime\"}";
        ParserConfig.getGlobalInstance().addAccept("java.lang");
        Runtime runtime = (Runtime) JSON.parseObject(json, Object.class);
        runtime.exec("calc.exe");
    }
}

到此这篇关于Java反射与Fastjson的危险反序列化的文章就介绍到这了,更多相关Java反射与Fastjson内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家!

您可能感兴趣的文章:
阅读全文