Java安全-类加载器

类加载机制

只谈论漏洞利用相关的话就是类加载时会执行代码

一些关键词：

初始化：调用静态代码块

实例化：调用构造代码块，无参构造函数

当直接加载class时没有调用静态代码块就不会执行代码

实例

代码来自视频https://www.bilibili.com/video/BV16h411z7o9?p=4&vd_source=74ab8e2b60b116cb6d199828a8fb5b1d
定义一个需要我们进行类加载的java文件

Person.java

public class Person {

    public String name;
    private int age;
    public static int id;
    static {
        System.out.println("静态代码块");
    }
    public  static void staticAction(){
        System.out.println("静态方法");
    }
    {
        System.out.println("构造代码块");
    }

    public Person() {
        System.out.println("无参构造方法");
    }

    public Person(String name, int age) {
        System.out.println("有参构造方法");
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

实例化
XINO.Java

public class XINO {
    public static void main(String[] args) {
        new Person("XINO",20);
    }
}

执行会依次调用静态代码块、匿名代码块、构造方法。
调用静态方法

public class XINO {
    public static void main(String[] args) {
        Person.staticAction();
    }
}

只进行了初始化，并没有实例化，不会执行构造代码块和构造方法
class类加载

public class XINO {
    public static void main(String[] args) {
        Class personClass = Person.class;
    }
}

只进行了类加载并没有进行初始化，不会调用任何代码块
Class.forName

如果我们只是这样写

Class<?> person = Class.forName("Person");

执行出了静态代码块，只给类名的情况下是默认会被初始化的，因为我们看一下

Class.forName("类名", 是否初始化类, 类加载器) 

我们不传第二个参数时，会执行forName0初始化部分默认为true 。大体就是这样的。

类加载器

引导类加载器（BootstrapClassLoader）

引导类加载器(BootstrapClassLoader)，native类型方法，所以底层原生代码是C++语言编写，属于jvm一部分，不继承java.lang.ClassLoader类，也没有父加载器，主要负责加载核心java库(即JVM本身)，存储在/jre/lib/rt.jar目录当中。(同时处于安全考虑，BootstrapClassLoader只加载包名为java、javax、sun等开头的类)。

扩展类加载器（ExtensionsClassLoader）

扩展类加载器（ExtensionsClassLoader）是引导类加载器（BootstrapClassLoader）的子集，其核心目的是加载标准核心Java类的扩展，以便适配平台上运行的所有应用程序。

由sun.misc.Launcher$ExtClassLoader类实现，用来在/jre/lib/ext或者java.ext.dirs中指明的目录加载java的扩展库。Java虚拟机会提供一个扩展库目录，此加载器在目录里面查找并加载java类。

系统类加载器（AppClassLoader）

App类加载器/系统类加载器（AppClassLoader），由sun.misc.Launcher$AppClassLoader实现，一般通过通过(java.class.path或者Classpath环境变量)来加载Java类，也就是我们常说的classpath路径。通常我们是使用这个加载类来加载Java应用类，可以使用ClassLoader.getSystemClassLoader()来获取它。

自定义加载器

我们也可以自定义加载器来满足一些需求。

双亲委派机制

我们需要某个类的时候，才将生成的class文件加载到内存当中生成class对象进行使用，且加载过程使用的是双亲委派模式，及把需要加载的类交由父加载器进行处理。但注意的是，他们之间并不是"继承"体系，而是委派体系。即parent为他们的属性，当上述特定的类加载器接到加载类的请求时，首先会先将任务委托给父类加载器，接着请求父类加载这个类，当父类加载器无法加载时（其目录搜素范围没有找到所需要的类时），子类加载器才会进行加载使用。

ClassLoader方法

loadClass(加载指定的Java类)
findClass(查找指定的Java类)
findLoadedClass(查找JVM已经加载过的类)
defineClass(定义一个Java类，将字节码解析成虚拟机识别的Class对象。往往和findClass()方法配合使用。)
resolveClass(链接指定的Java类)

类加载的过程

加载class有两种方式

• 隐式加载：JVM 自动加载需要的类到内存中
• 显式加载：通过 class.forName() 动态加载 class文件到 jvm 中
  简单看一下类加载的过程：

加载阶段 ：该阶段是类加载过程的第一个阶段，会通过一个类的完全限定名称来查找类的字节码文件，并利用字节码文件来创建一个 Class 对象。

验证阶段 ：该阶段是类加载过程的第二个阶段，其目的在于确保 Class 文件中包含的字节流信息符合当前 Java 虚拟机的要求。

准备阶段： 该阶段会为类变量在方法区中分配内存空间并设定初始值( 这里 “类变量” 为static修饰符修饰的字段变量 )

不会分配并初始化用 final 修饰符修饰的 static 变量，因为该类变量在编译时就会被分配内存空间。

不会分配并初始化实例变量，因为实例变量会随对象一起分配到 Java 堆中，而不是 Java 方法区。

解析阶段 ：该阶段会将常量池中的符号引用替换为直接引用。

初始化阶段 ：该阶段是类加载的最后阶段，如果当前类具有父类，则对其进行初始化，同时为类变量赋予正确的值。

我们就简单看一下，loadClass 方法

    protected Class<?> loadClass(String name, boolean resolve)
        throws ClassNotFoundException
    {
        synchronized (getClassLoadingLock(name)) {
            // First, check if the class has already been loaded
            Class<?> c = findLoadedClass(name);
            if (c == null) {
                long t0 = System.nanoTime();
                try {
                    if (parent != null) {
                        c = parent.loadClass(name, false);
                    } else {
                        c = findBootstrapClassOrNull(name);
                    }
                } catch (ClassNotFoundException e) {
                    // ClassNotFoundException thrown if class not found
                    // from the non-null parent class loader
                }

                if (c == null) {
                    // If still not found, then invoke findClass in order
                    // to find the class.
                    long t1 = System.nanoTime();
                    c = findClass(name);

                    // this is the defining class loader; record the stats
                    PerfCounter.getParentDelegationTime().addTime(t1 - t0);
                    PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
                    PerfCounter.getFindClasses().increment();
                }
            }
            if (resolve) {
                resolveClass(c);
            }
            return c;
        }
    }

首先是findLoadedClass ，查看是否已经加载了，加载了就结束，没加载就继续，如果存在父加载器，就调用父类的加载器进行进行加载。如果不存在父加载器就调用JVM默认类加载器进行加载即：BootstrapClassLoade(c=findBootstrapClassOrNull(name))r；这也就解释了ExtClassLoader的parent为null，所以继续向上委派.
若找到了对应的类，并且接收到的resolve参数的值为true,那么就会调用resolveClass(Class)方法来处理类。如果还是找不到的话，就c = findClass(name);，调用findClass方法进行类的寻找。但是findClass方法是空的：

protected Class<?> findClass(String name) throws ClassNotFoundException {
    throw new ClassNotFoundException(name);
}

这里其实就是双亲委派的体现，若没找到，findClass为空这时就需要我们自定义类加载器。

自定义加载器

若要做到自定义加载器，则需要我们做到

1.编写一个类继承自ClassLoader抽象类。
2.重写它的findClass()方法。
3.在findClass ()方法中调用defineClass( ) 
这里说实话没有做到很好的理解，用了其他师傅的代码做一下示范：

1.TestClassLoader.java重写findClass

import java.io.*;

public class TestClassLoader extends ClassLoader
{
    private String classPath;
    public TestClassLoader(String classPath){
        this.classPath = classPath;
    }
    private String getFileName(String fileName){
        int index = fileName.lastIndexOf('.');
        if (index == -1){
            return fileName + ".class";
        }else {
            return fileName.substring(index + 1) + ".class";
        }
    }

    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        String fileName = getFileName(name);

        File file = new File(classPath, fileName);
        try {
            FileInputStream fileInputStream = new FileInputStream(file);
            ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
            int len = 0;
            try {
                while ((len = fileInputStream.read()) != -1) {
                    byteArrayOutputStream.write(len);
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            byte[] data = byteArrayOutputStream.toByteArray();
            fileInputStream.close();
            byteArrayOutputStream.close();
            return defineClass(name, data, 0, data.length);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }

        return super.findClass(name);
    }
}

2.TestHelloWorld.java

public class TestHelloWorld
{
    public String hello(){
        return "Hello!";
    }
}

3.JvmLearn.java,路径为TestHelloWorld.class的存放路径

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.net.MalformedURLException;



public class JvmLearn
{

    public static void main(String[] args) throws ClassNotFoundException, InvocationTargetException, NoSuchMethodException, IllegalAccessException, InstantiationException, MalformedURLException {
        test1();
    }
    public static void test1() throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, IllegalAccessException, InstantiationException {
        TestClassLoader classLoader = new TestClassLoader("C:\\Users\\del'l'\\Desktop\\");
        Class clazz = classLoader.loadClass("TestHelloWorld");
        Object o = clazz.newInstance();
        Method m = clazz.getMethod("hello");
        System.out.println(m.invoke(o));

    }

}

至于怎么重写以后再研究吧

参考博客：Java ClassLoader 学习笔记_bfengj的博客-CSDN博客

参考博客：https://blog.csdn.net/weixin_54902210/article/details/125016788?spm=1001.2014.3001.5502