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

​​​​​​​
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!");
        }
    }
}

// 通过循环遍历获得方法名
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());
}

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);

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();
        }
    }
}

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();
        }
    }
}

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");
    }
}