Java反序列化基础-类的动态加载-易微帮

类加载器&双亲委派

什么是类加载器

类加载器是一个负责加载器类的对象，用于实现类加载的过程中的加载这一步。
每个Java类都有一个引用指向加载它的ClassLoader。而数组类是由JVM直接生成的（数组类没有对应的二进制字节流）

类加载器有哪些

JVM 中内置了三个重要的 ClassLoader：

BootstrapClassLoader（启动类加载器）：最顶层的加载类，由C++实现，通常表示为null，并且没有父级，主要用来加载JDK内部的核心类库，以及被-Xbootclasspath参数指定路径下的所有类。
ExtensionClassLoader（扩展类加载器）：主要负责 “%JRE_HOME%/lib/ext” 目录下的jar包和类以及被 “java.ext.dirs” 系统变量所指定路径下的所有类。
AppClassLoader（应用程序类加载器）：面向用户的加载器，负责加载应用类的path下的所有jar包和类。

还有一个是用户自定义类加载器：

User ClassLoader

什么是双亲委派

当一个类加载器收到类加载器的请求的时候，它不会直接加载指定的类，而是把这个请求委托给自己的父加载器去加载器。只有父加载器无法加载这个类的时候，才会由当前这个加载器来负责类的加载。
双亲委派的好处就是一个类名只会被一个加载器加载

类加载不同代码的加载顺序

这里的代码块主要有以下四种：

静态代码块：static{}
构造代码块：{}
无参构造器：ClassName()
有参构造器：ClassName(String name)

实例化对象

Person.java：里面有静态代码块、构造代码块、无参构造器、有参构造器、静态成员变量、普通成员变量、静态方法。
Main.java：启动类

Person.java

package Class;

public class Person {
    public static int statica;
    public int instancea;

    static {
        System.out.println("静态代码块");
    }

    Person(){
        System.out.println("无参构造器");
    }

    {
        System.out.println("构造代码块");
    }



    public Person(int instancea) {
        this.instancea = instancea;
        System.out.println("有参构造"+ this.instancea);
    }


    public static void staticAction(){
        System.out.println("静态方法");
    }
}

Main.java

package Class;

public class Main {
    public static void main(String[] args) throws ClassNotFoundException{
        Person person = new Person();

    }
}

运行之后可以看见，调用的顺序是：
静态代码块->构造代码块->无参构造器

调用静态方法

调用Person的静态方法
Main.java

package Class;

public class Main {
    public static void main(String[] args) throws ClassNotFoundException{
        Person.staticAction();

    }
}

运行Main.java后，可以看见没有实例化对象会先调用：
静态代码块->静态方法

对静态成员变量赋值

Main.java

package Class;

public class Main {
    public static void main(String[] args) throws ClassNotFoundException{
        Person.statica = 1;
    }
}

对静态成员变量赋值，也会调用静态代码块

使用class获取类

Main.java

package Class;

public class Main {
    public static void main(String[] args) throws ClassNotFoundException{
        Class c = Person.class;

    }
}

运行后没有输出

使用forName获取类

获取类的class

需要在main方法上主动抛出异常
Main.java

package Class;

public class Main {
    public static void main(String[] args) throws ClassNotFoundException{
        Class.forName("Class.Person");
    }
}

运行之后，可以看见调用了静态代码块

有true

Main.java

package Class;

public class Main {
    public static void main(String[] args) throws ClassNotFoundException{
        Class.forName("Class.Person",true,ClassLoader.getSystemClassLoader());
    }
}

调用静态代码块

有false

Main.java

package Class;

public class Main {
    public static void main(String[] args) throws ClassNotFoundException{
        Class.forName("Class.Person",false,ClassLoader.getSystemClassLoader());
    }
}

可以看见没有调用任何代码块

使用ClassLoader.loadClass() 获取类

Main.java

package Class;

public class Main {
    public static void main(String[] args) throws Exception{
        ClassLoader cl = ClassLoader.getSystemClassLoader();
        Class<?> c = cl.loadClass("Class.Person");
        c.newInstance();// 初始化类
    }
}

添加了 c.newInstance()可以看见调用了以下，否则不调用

动态加载字节码

什么是字节码？

Java中的字节码，英文名为 “bytecode”，是Java代码编译后的中间代码格式。JVM（Java虚拟机）执行使用的一类指令，字节码通常存储在 .class文件中。

javac Hello.java

这里使用 javac命令编译我们写好的java文件，可以看见生成了一个 Hello.class文件，这个就是字节码文件

我们打开Hello.class文件看一下，可以看见都是一些看不懂的文件，这些是需要JVM去做的事情，才能执行

可以看见执行的时候，也会输出成功，因为java加载了字节码

类加载器的原理

注意：

复现的时候JDK版本不可以太高，否则会不一样

JDK下载：

https://blog.csdn.net/weixin_51959343/article/details/135921731

这里主要断点调试 loadClass 这一行

这个时候就会来到它的父类抽象类 ClassLoader，然后调用 loadClass()的两个参数

继续跟进来到了 AppClassLoader的loadClass()

走到下面是双亲委派的逻辑，调用父类的loadClass重复查询

这个时候又回到了 ClassLoader()类中

来到所属的 Launcher类中，Ctrl + H 可以看见，类的流程关系是：
ClassLoader —-> SecureClassLoader —> URLClassLoader —-> APPClassLoader

后面继续断点跟踪调试可以发现，函数调用顺序：
loadClass() -> findClass() -> defineClass()

任意类加载class文件

urlClassLoader

编译一个Calc类的字节码文件

package Class;

import java.io.IOException;

public class Calc {
    static {
        try {
            Runtime.getRuntime().exec("calc");
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

然后编写urlClassLoader的启动类

package Class;

public class Main {
    public static void main(String[] args) throws Exception{
        URLClassLoader urlClassLoader = new URLClassLoader(new URL[]{new URL("file://编译后的class文件位置路径//")});
        Class<?> c = urlClassLoader.loadClass("Class.Calc"); 
        c.newInstance();
    }
}

运行之后可以看见成功弹出了计算器

也可以使用http协议进行远程加载

package Class;

public class Main {
    public static void main(String[] args) throws Exception{
    URLClassLoader urlClassLoader = new URLClassLoader(new URL[]{new URL("http://localhost:8080")});
        Class<?> c = urlClassLoader.loadClass("Class.Calc"); 
        c.newInstance();
    }
}

在字节码文件目录下开启http服务

运行之后可以看见弹出计算器

也可以使用jar，

前面 jar:
后面 xxx.jar!/

package Class;

public class Main {
    public static void main(String[] args) throws Exception{
        URLClassLoader urlClassLoader = new URLClassLoader(new URL[]{new URL("jar:http://localhost:8080/Calc.jar!/")});
        Class<?> c = urlClassLoader.loadClass("Class.Calc");
        c.newInstance();
    }
}

file协议同理

defineClass

也可以直接使用 defineClass方法加载恶意的class文件

package Class;


public class Main {
    public static void main(String[] args) throws Exception{

        //获取ClassLoader类的系统类加载器赋值到c1变量
        ClassLoader cl = ClassLoader.getSystemClassLoader();
        
        //使用反射机制获取 ClassLoader 类的 defineClass 方法中的一些一些参数
        Method defineClassCalc = ClassLoader.class.getDeclaredMethod("defineClass", String.class, byte[].class, int.class, int.class);
        
        //设置权限为可访问
        defineClassCalc.setAccessible(true);
        
        //byte[]数组存储了，这个目录下的Calc.class字节码文件
        byte[] code = Files.readAllBytes(Paths.get(("E:\\语言学习\\java\\code\\Serialize1\\Serialize1\\out\\production\\Serialize1\\Class\\Calc.class")));

        //反射调用了之前获取到的 defineClass 方法，将字节码数组转换为 Class 对象赋值给c
        Class c = (Class) defineClassCalc.invoke(cl,"Class.Calc",code,0,code.length);
        
        //初始化 Class对象 c
        c.newInstance();
    }
}

缺点就是 defineClass方法是protected受保护的成员，在反序列化中难以反射调用

Unsafe

Unsafe 方法，是采用单例模式进行设计的，无法直接调用，所以需要反射

package Class;


public class Main {
    public static void main(String[] args) throws Exception{

        //获取ClassLoader类的系统类加载器赋值到c1变量
        ClassLoader cl = ClassLoader.getSystemClassLoader();

        //获取 Unsafe的类
        Class<Unsafe> unsafeClass = Unsafe.class;

        //通过反射 获取 Unsafe类的 theUnsafe字段
        Field theUnsafeField = unsafeClass.getDeclaredField("theUnsafe");

        //设置访问权限为true，theUnsafe是prvate成员
        theUnsafeField.setAccessible(true);

        byte[] code = Files.readAllBytes(Paths.get(("E:\\语言学习\\java\\code\\Serialize1\\Serialize1\\out\\production\\Serialize1\\Class\\Calc.class")));

        //获取 Unsafe对象theUnsafeField方法静态的字段的值
        Unsafe unsafe = (Unsafe) theUnsafeField.get(null);
        Class c2 = unsafe.defineClass("Class.Calc", code, 0, code.length, cl, null);
        c2.newInstance();

    }
}

总结

总的来说就是加载器字节码之间怎么构造一条链子，底层之间产生的漏洞

Java反序列化基础-类的动态加载

类加载器&双亲委派

什么是类加载器

类加载器有哪些

什么是双亲委派

类加载不同代码的加载顺序

实例化对象

调用静态方法

对静态成员变量赋值

使用class获取类

使用forName获取类

获取类的class

有true

有false

使用ClassLoader.loadClass() 获取类

动态加载字节码

什么是字节码？

类加载器的原理

任意类加载class文件

urlClassLoader

defineClass

Unsafe

总结

网站公告

今日签到

热门文章

最新发布