JAVA ClassLoader类加载机制以及双亲委派机制和内存马注入
参考文章：https://javasec.org/javase/ClassLoader/
关于类的加载机制，结果javasec和自己的理解来记录的一篇文章！！！
概念的学习
首先得知道的两点：
第一点：
Java是一个依赖于JVM(Java虚拟机)实现的跨平台的开发语言
第二点：类实例化的工作流程：
1、Java程序在运行前需要先编译成class文件（字节码），这个class文件其实就是我们的javac生成的！
2、Java类初始化的时候会调用ClassLoader对象（这里的ClassLoader其实也是一个类）加载类字节码（也就是class文件）
3、ClassLoader会调用JVM的native方法(defineClass0/1/2)来定义一个java.lang.Class实例。
现在知道了两个概念：
1、JAVA的运行依赖于JAVA虚拟机
2、类的初始化需要ClassLoader对象
3、想要生成对应的类实例就需要ClassLoader去加载对应类的字节码（也就是class文件）
注意：这里说的Class实例，并不是如Unsafe unsafe = new Unsafe()这里面生成的unsafe实例，此unsafe实例跟这里的类实例不同的，为什么？
就比如这一句话：ClassLoader.getSystemClassLoader().loadClass("java.lang.String");，看着意思就是一个ClassLoader类中的getSystemClassLoader方法返回了一个对象然后调用该对象的loadClass方法加载了一个名为java.lang.String类，那么这里其实就知道了主要加载类的方法就是loadClass
可以观察下该loadClass返回的是什么，如下，那么也就知道了这是一个名叫Class类型的对象，那么也就是返回的是一个Class类型的对象，那么也就证实了上面说的，unsafe实例跟这里的Class实例不同！
ClassLoader的介绍
观察如下一张图：
1、可以看到ClassLoader是位于JVM里面的
2、所有的类的实例化都需要经过ClassLoader
总结：上面的图中可以看到一切的Java类都必须经过JVM加载后才能运行，而ClassLoader的主要作用就是对字节码文件的加载，使得内存中产生Class对象！
在正常的JVM中，Java自带的三个类加载器
Bootstrap Classloder
Extention ClassLoader
App ClassLoader
引导类加载器 Bootstrap Classloder：
这个类加载器使用 C/C++语言实现的，嵌套在 JVM 内部，java 程序无法直接操作这个类，下面也可以体现为什么说java程序无法直接操作，测试代码如下，可以看到Launcher$ExtClassLoader通过getParent()获得的还是Launcher$ExtClassLoader对象，原因就是这个Bootstrap ClassLoader是c/c++实现的，jvm中无法获取。
它用来加载Java核心类库如 ： JAVA_HOME/jre/lib/rt.jar、resources.jar、sun.boot.class.path 路径下的包，用于提供 jvm 运行所需的包。启动类加载器并不是继承自java.lang.ClassLoader，它没有父类加载器。但是它加载扩展类加载器和应用程序类加载器，并成为他们的父类加载器。
扩展类加载器 Extension ClassLoader：
Java 语言编写，由 sun.misc.Launcher$ExtClassLoader 实现，我们可以用 Java 程序操作这个加载器派生继承自 java.lang.ClassLoader，父类加载器为启动类加载器从系统属性：java.ext.dirs 目录中加载类库，或者从 JDK 安装目录：jre/lib/ext 目录下加载类库。我们就可以将我们自己的包放在以上目录下，就会自动加载进来了。
应用程序类加载器 Application Classloader：
Java语言编写，由sun.misc.Launcher$AppClassLoader实现。派生继承自java.lang.ClassLoader，父类加载器为启动类加载器它负责加载环境变量 classpath 或者系统属性 java.class.path 指定路径下的类库它是程序中默认的类加载器，我们 Java 程序中的类，都是由它加载完成的。我们可以通过 ClassLoader#getSystemClassLoader()获取并操作这个加载器
双亲委派机制
这个知识点非常重要，在之后的java代码安全中都会看到
知识点：
1、在JVM类加载器中最顶层的是Bootstrap ClassLoader(引导类加载器)，接着就是Extension ClassLoader(扩展类加载器)、App ClassLoader(系统类加载器)。
2、App ClassLoader是默认的类加载器，如果类加载时我们不指定类加载器的情况下，默认会使用App ClassLoader加载类，ClassLoader.getSystemClassLoader()返回的系统类加载器就是AppClassLoader。
这里注意的是：虽然默认使用的App ClassLoader加载类，但是加载顺序却是不同的，下面开始来讲关于加载顺序，造成加载顺序不同的原因还是双亲委派机制的问题
然后继续说，上面说了ClassLoader对象有如上三种，其他的就是我们自己重写的ClassLoader类了
上一级称为下一级的父加载器（怎么理解，也就是Extention ClassLoader是App ClassLoader的父加载器，Bootstrap ClassLoader是Extention ClassLoader的父加载器）
加载的先后顺序依次是：Bootstrap ClassLoader => Extention ClassLoader => App ClassLoader
图中可以知道：当自己通过类加载器来进行类加载和加载类生成的时候，其加载顺序是有进行委派操作的
如上图中所示，当一个类加载器查找class和resource的时候，首先判断这个class是不是已经加载成功；如果没有的话它并不是自己进行查找，而是先委托给父加载器，然后递归委托，直到Bootstrap ClassLoader加载器；如果Bootstrap classloader找到了，直接加载并且返回class和resource；如果没有找到，则一级一级返回，最后才是自己（这里的自己正常的肯定就是App ClassLoader，要不然就是你的自定义的类加载器）去查找加载。
知识点：某些时候我们获取一个类的类加载器时候可能会返回一个null值，如：java.io.File.class.getClassLoader() 将返回一个null对象，因为java.io.File类在JVM初始化的时候会被Bootstrap ClassLoader(引导类加载器)加载(该类加载器实现于JVM层，采用C++编写)，我们在尝试获取被Bootstrap ClassLoader类加载器所加载的类的ClassLoader时候都会返回null，这个其实上面有讲到过，这里再提及下。
双亲委派机制是如何实现的？
上面介绍了双亲委派机制，了解到的就是 如果是AppClassLoader类来进行加载的话，首先会让上层进行加载，这里来看下AppClassLoader的实现
测试代码：
com.zpchcbd.becl.Example.java
public class Example {
static{
try{
Runtime.getRuntime().exec("calc");
}catch(Exception e){
}
}
}
主函数.java
public class Test {
public static void main(String[] args) throws ClassNotFoundException {
Class<?> aClass = ClassLoader.getSystemClassLoader().loadClass("com.zpchcbd.bcel.Example");
System.out.println(aClass);
}
}
这里对AppClassLoader的super.loadClass(var1,var2)再下一个条件断点，要不然正常的话AppClassLoader启动就需要加载很多，所以需要先过滤
接着再调试运行，默认就来到super.loadClass方法
继续走进去，走到的就是父类的ClassLoader类的loadClass，这里来到的就是调用parent.loadClass(name, false)，也就是通过上一级的ClassLoader的loadClass方法来进行调用
单步走过去，可以看到上一级的ExtClassLoader并没有加载出来（我这里没有跟进去，如果这里的ExtClassLoader同样也没有加载出来，那么还是会让Bootstrap再去加载，这里就不截图了）
继续单步走，此时就是当前的AppClassLoader 自己来进行loadClass
可以发现当前自己AppClassLoader通过loadClass加载出来了
到这里也同样可以体现双亲委派这个机制！
打破双亲委派机制
有时候就是想要让自己实现的类加载器直接去进行加载，而不是用委派机制来进行委派先让Bootstrap来进行加载，此时就需要打破双亲委派机制
如果想打破双亲委派模型，那么就重写整个 loadClass 方法即可
如下所示
ClassLoader最重要的如下5个方法：
1. loadClass (加载指定的Java类)
2. findClass (查找指定的Java类)
3. findLoadedClass (查找JVM已经加载过的类)
4. defineClass (定义一个Java类)
5. resolveClass (链接指定的Java类)
第一个方法，loadClass，一开始在开头也稍微介绍了下，该方法的作用是加载指定的Java类，跟一下这个方法
public Class<?> loadClass(String name) throws ClassNotFoundException {
return loadClass(name, false);
}
这里调用了一个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); //这里先进行判断要加载的类名对应的类实例是否已经加载过了，这里findLoadedClass的作用其实就是 如果该类实例已经加载过了，那么它后续的操作就会直接返回
if (c == null) { //如果为空，那么也就是没有加载
long t0 = System.nanoTime();
try {
if (parent != null) {
c = parent.loadClass(name, false); // 如果实例化ClassLoader的时候传入了父类加载器(new ClassLoader(你传入的父类加载器))就使用父类加载器加载TestHelloWorld类，否则使用JVM的Bootstrap ClassLoader加载。
} else {
c = findBootstrapClassOrNull(name); // 否则使用JVM的Bootstrap ClassLoader加载
}
} 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); // 这里就是上面的都找不到 然后就会调用自身的findClass方法去加载指定的类，其实这里体现的就是你的自定义加载器了，也就是说如果没有自定义加载器重写findClass方法，那肯定也是没有找到的，这里如果找到了就默认返回一个java.lang.Class类对象，也就是对应类型的class实例
// this is the defining class loader; record the stats
sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0);
sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
sun.misc.PerfCounter.getFindClasses().increment();
}
}
if (resolve) {
resolveClass(c);
}
return c;
}
}
下面通过自定义类加载器来打破双亲委派机制
自定义的类加载器
上面说了，如果都找不到就会用到我们的自定义加载器，同样的上面的类加载器也确实符合双亲委派模式
那么如何实现类加载器？只需要重写findClass方法就行！
这里先说下如何将字节码文件转换为byte数组，然后在java中通过defineClass来自己进行实例化，这里用的Y4er哥先知上的文章的代码，代码如下：
public class Test {
public static void main(String[] args) throws IOException, ClassNotFoundException {
byte[] bs = getBytesByFile("C:\\Users\\secAdmin\\Desktop\\All\\javaApp4\\servlet2\\src\\main\\java\\com\\anbai\\sec\\cmd\\CommandExecution.class");
for (int i = 0; i < bs.length; i++) {
System.out.print(bs[i]+", ");
}
}
public static byte[] getBytesByFile(String pathStr) {
File file = new File(pathStr);
try {
FileInputStream fis = new FileInputStream(file);
ByteArrayOutputStream bos = new ByteArrayOutputStream(1000);
byte[] b = new byte[1000];
int n;
while ((n = fis.read(b)) != -1) {
bos.write(b, 0, n);
}
fis.close();
byte[] data = bos.toByteArray();
bos.close();
return data;
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
}
继续回来将如何实现自定义类的加载器，这里用到的还是javasec中的TestHelloWorld类作为要实例化的对象：
package com.java.classloader;
import java.lang.reflect.Method;
public class TestClassLoader extends ClassLoader {
// TestHelloWorld类名
public static String TEST_CLASS_NAME = "com.java.classloader.TestHelloWorld";
// TestHelloWorld类字节码
public static byte[] TEST_CLASS_BYTES = new byte[]{
-54, -2, -70, -66, 0, 0, 0, 51, 0, 17, 10, 0, 4, 0, 13, 8, 0, 14, 7, 0, 15, 7, 0,
16, 1, 0, 6, 60, 105, 110, 105, 116, 62, 1, 0, 3, 40, 41, 86, 1, 0, 4, 67, 111, 100,
101, 1, 0, 15, 76, 105, 110, 101, 78, 117, 109, 98, 101, 114, 84, 97, 98, 108, 101,
1, 0, 5, 104, 101, 108, 108, 111, 1, 0, 20, 40, 41, 76, 106, 97, 118, 97, 47, 108,
97, 110, 103, 47, 83, 116, 114, 105, 110, 103, 59, 1, 0, 10, 83, 111, 117, 114, 99,
101, 70, 105, 108, 101, 1, 0, 19, 84, 101, 115, 116, 72, 101, 108, 108, 111, 87, 111,
114, 108, 100, 46, 106, 97, 118, 97, 12, 0, 5, 0, 6, 1, 0, 12, 72, 101, 108, 108, 111,
32, 87, 111, 114, 108, 100, 126, 1, 0, 40, 99, 111, 109, 47, 97, 110, 98, 97, 105, 47,
115, 101, 99, 47, 99, 108, 97, 115, 115, 108, 111, 97, 100, 101, 114, 47, 84, 101, 115,
116, 72, 101, 108, 108, 111, 87, 111, 114, 108, 100, 1, 0, 16, 106, 97, 118, 97, 47, 108,
97, 110, 103, 47, 79, 98, 106, 101, 99, 116, 0, 33, 0, 3, 0, 4, 0, 0, 0, 0, 0, 2, 0, 1,
0, 5, 0, 6, 0, 1, 0, 7, 0, 0, 0, 29, 0, 1, 0, 1, 0, 0, 0, 5, 42, -73, 0, 1, -79, 0, 0, 0,
1, 0, 8, 0, 0, 0, 6, 0, 1, 0, 0, 0, 7, 0, 1, 0, 9, 0, 10, 0, 1, 0, 7, 0, 0, 0, 27, 0, 1,
0, 1, 0, 0, 0, 3, 18, 2, -80, 0, 0, 0, 1, 0, 8, 0, 0, 0, 6, 0, 1, 0, 0, 0, 10, 0, 1, 0, 11,
0, 0, 0, 2, 0, 12
};
@Override
public Class<?> findClass(String name) throws ClassNotFoundException {
// 只处理TestHelloWorld类
if (name.equals(TEST_CLASS_NAME)) {
// 调用JVM的native方法定义TestHelloWorld类
return defineClass(TEST_CLASS_NAME, TEST_CLASS_BYTES, 0, TEST_CLASS_BYTES.length);
}
return super.findClass(name);
}
public static void main(String[] args) {
// 创建自定义的类加载器
TestClassLoader loader = new TestClassLoader();
try {
// 使用自定义的类加载器加载TestHelloWorld类
Class testClass = loader.loadClass(TEST_CLASS_NAME);
// 反射创建TestHelloWorld类，等价于 TestHelloWorld t = new TestHelloWorld();
Object testInstance = testClass.newInstance();
// 反射获取hello方法
Method method = testInstance.getClass().getMethod("hello");
// 反射调用hello方法,等价于 String str = t.hello();
String str = (String) method.invoke(testInstance);
System.out.println(str);
} catch (Exception e) {
e.printStackTrace();
}
}
}
