b319776ea6c0701aef0cae08f99b3022

还是大部分放在学习开发上面，但是也是引入了Java安全的知识，二者同步学习吧也是。

前言

JVM（Java虚拟机）中的动态类加载是一种在运行时加载类的机制，它允许应用程序在不重新启动的情况下加载新的类。它对Java应用程序的灵活性和扩展性至关重要。

什么是Java的“字节码”

严格来说，Java字节码（ByteCode）其实仅仅指的是Java虚拟机执行使用的一类指令，通常被存储在.class文件中。众所周知，不同平台、不同CPU的计算机指令有差异，但因为Java是一门跨平台的编译型语言，所以这些差异对于上层开发者来说是透明的，上层开发者只需要将自己的代码编译一次，即可运行在不同平台的JVM虚拟机中。甚至，开发者可以用类似Scala、Kotlin这样的语言编写代码，只要你的编译器能够将代码编译成.class文件，都可以在JVM虚拟机中运行：

类加载机制

JVM（Java虚拟机）的类加载机制是指JVM在运行Java程序时，如何加载、连接和初始化类的过程。这个机制保证了Java程序在运行时能够正确地加载所需的类。

JVM的类加载机制主要分为以下三个阶段：

加载（Loading）

加载是类加载的第一个阶段。在加载阶段，类加载器将.class文件（字节码文件）读入内存，并转化成运行时数据结构（也称为方法区）。加载阶段不会执行类的初始化，仅仅是将类的二进制数据读取到内存中。

Java类加载器

类加载器，顾名思义，就是用来实现类的加载操作。每个类加载器都有一个独立的类名称空间，就是说每个由该类加载器加载的类，都在自己的类名称空间，如果要比较两个类是否“相等”，首先这两个类必须在相同的类命名空间，即由相同的类加载器加载（即对于任何一个类，都必须由该类本身和加载它的类加载器一起确定其在JVM中的唯一性），不是同一个类加载器加载的类，不会相等。

1610974298067065243

启动类加载器（Bootstrap Class Loader）：这个类使用C++开发（所有的类加载器中，唯一使用C++开发的类加载器），用来加载/lib目录中jar和tools.jar或者使用 -Xbootclasspath 参数指定的类。
扩展类加载器（Extension Class Loader）：定义为misc.Launcher$ExtClassLoader，用来加载/lib/ext目录或者使用java.ext.dir指定的类。
应用程序类加载器（Application Class Loader）：定义为misc.Launcher$AppClassLoader，用来加载用户类路径下面（classpath）下面所有的类，一般情况下，该类是应用程序默认的类加载器。
用户自定义类加载器（User Class Loader）：用户自定义类加载器，一般没有必要，后面我们会专门来一部分介绍该类型的类加载器。

双亲委派模型

双亲委派模型，是从 Java1.2 开始引入的一种类加载器模式，在Java中，类的加载操作通过java.lang.ClassLoader中的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
                sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0);
                sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
                sun.misc.PerfCounter.getFindClasses().increment();
            }
        }
        if (resolve) {
            resolveClass(c);
        }
        return c;
    }
}

接收到一个类加载请求后，首先判断该类是否有加载，如果已经加载，则直接返回；

如果尚未加载，首先获取父类加载器，如果可以获取父类加载器，则调用父类的loadClass()方法来加载该类，如果无法获取父类加载器，则调用启动器加载器来加载该类；

判断该类是否被父类加载器或者启动类加载器加载，如果已经加载完成则返回，如果未成功加载，则自己尝试来加载该类。

上面的描述，说明了loadClass()方法的实现，我们进一步对上面的步骤进行解释：

因为类加载器首先调父类加载器来进行加载，从loadClass()方法的实现，我们知道父类加载器会尝试调自己的父类加载器，直到启动类加载器，所以，任何一个类的加载，都会最终委托到启动类加载器来首先加载；
在前面有进行介绍，启动类加载器、扩展类加载器、应用程序类加载器，都有自己加载的类的范围，例如启动类加载器只加载JDK核心库，因此并不是父类加载器就可以都加载成功，父类加载器无法加载（一般如上面代码，抛出来ClassNotFoundException），此时会由自己加载。

总结：

双亲委派模型：如果一个类加载器收到类加载请求，会首先把加载请求委派给父类加载器完成，每个层次的类加载器都是这样，最终所有的加载请求都传动到最根的启动类加载器来完成，如果父类加载器无法完成该加载请求（即自己加载的范围内找不到该类），子类加载器才会尝试自己加载。

这样的双亲委派模型有个好处：就是所有的类都尽可能由顶层的类加载器加载，保证了加载的类的唯一性，如果每个类都随机由不同的类加载器加载，则类的实现关系无法保证，对于保证Java程序的稳定运行意义重大。

链接（Linking）

链接阶段进一步分为三个阶段：验证、准备和解析。a. 验证（Verification）：在这个阶段，JVM会对加载的字节码进行校验，以确保其符合JVM规范。包括类型检查、字节码验证、符号引用验证等。b. 准备（Preparation）：在准备阶段，JVM会为类的静态变量分配内存，并设置默认初始值。这里不包括使用final修饰的静态变量，因为它们已在编译期间分配了初始值。c. 解析（Resolution）：解析阶段是将类中的符号引用解析成直接引用的过程，例如将类、方法、字段的引用转化为内存地址。

初始化（Initialization）

初始化阶段是类加载的最后一个阶段。在这个阶段，JVM会执行类的初始化代码，包括静态变量的赋值和静态代码块的执行。类初始化时机：当对类的静态成员进行赋值时（如静态变量的赋值）。当调用类的静态方法时。当使用new关键字实例化对象时（但实际对象的初始化在构造函数中）。当访问或者初始化一个类的子类时，父类也会被初始化。当启动Java应用程序的主类时。

这个类加载机制保证了类在首次使用时才会被加载，同时保证了类的初始化在多线程环境下的安全性。

动态类加载

动态类加载是指在程序运行时，根据需要动态地加载类或接口的过程。Java中的动态类加载主要通过Java的反射API和类加载器来实现。

它主要应用在一些需要动态扩展的应用场景，例如插件系统，或者在应用启动时需要动态决定需要加载哪些类的情况。使用动态类加载需要注意的是，最好明确需要加载的类的路径和名称，避免在运行时出现找不到类的错误。同时，对于动态加载的类，其安全性也是需要特别关注的。

工作原理

JVM（Java虚拟机）中的动态类加载是一种在运行时加载类的机制，它允许应用程序在不重新启动的情况下加载新的类。以下是JVM中动态类加载的工作原理：

类加载器层次结构：JVM中的类加载机制是分层的，通常包括以下三个主要层次：启动类加载器、扩展类加载器和应用程序类加载器。这些加载器形成了父子关系，构成了双亲委派模型。
双亲委派模型：在动态类加载中，JVM首先检查是否已经加载了所请求的类。它通过遵循双亲委派模型来执行这一检查。按照这一模型，JVM首先将类加载请求委派给父类加载器（启动类加载器、扩展类加载器），如果父类加载器无法找到该类，才会由当前类加载器（应用程序类加载器）尝试加载。
自定义类加载器：动态类加载通常涉及自定义类加载器。应用程序可以编写自定义类加载器，这些加载器可以加载不在类路径中的类。自定义类加载器必须继承自java.lang.ClassLoader类，并覆盖其中的loadClass方法来实现类加载逻辑。
类字节码的获取：在动态类加载中，通常需要获取类的字节码。这可以通过多种方式实现，例如从文件系统、网络或其他外部资源中获取。获取类字节码的方式取决于应用程序的具体需求。
类加载过程：当自定义类加载器的loadClass方法被调用时，它首先会检查是否已经加载了该类。如果已加载，它会返回已加载的类。否则，它将尝试委派给父类加载器加载。
类加载成功：如果父类加载器无法加载该类（双亲委派模型），自定义类加载器会尝试加载类字节码。一旦类字节码被加载，它可以通过defineClass方法将类定义为JVM可识别的类。
类初始化：一旦类被成功加载，JVM会执行类的初始化过程，包括执行静态初始化块和静态变量的赋值。这确保了类在使用之前已经准备好。

动态类加载允许应用程序在运行时引入新的类，这对于插件系统、热部署和动态扩展非常有用。但需要小心使用，因为错误的类加载和卸载可能导致内存泄漏或不稳定的应用程序行为。因此，在实施动态类加载时，应仔细考虑安全性和性能方面的问题。

实现方式

动态类加载是指在Java应用程序运行时，根据需要加载类的能力。这可以通过多种方式实现，以下是一些常见的动态类加载实现方式：

Java反射

Java的反射机制允许在运行时加载和操作类，方法和字段。
使用Class.forName()方法或类的Class对象的newInstance()方法可以动态加载和实例化类。
可以通过反射来访问和调用类的成员和方法。
优点：灵活性高，适用于各种情况。
缺点：性能开销较大，容易导致运行时错误。

实例：

DynamicClass.java

package DynamicLoadingOfClasses;

public class DynamicClass {
    public void hello() {
        System.out.println("Hello, Dynamic Class!");
    }
}

DynamicClassLoadingExample.java

package DynamicLoadingOfClasses;


import java.lang.reflect.Method;

public class DynamicClassLoadingExample {
    public static void main(String[] args) {
        try {
            // 1. 使用反射加载类
            Class<?> dynamicClass = Class.forName("DynamicLoadingOfClasses.DynamicClass");

            // 2. 创建类的实例
            Object dynamicObject = dynamicClass.getDeclaredConstructor().newInstance();

            // 3. 调用类的方法
            Method method = dynamicClass.getMethod("hello");
            method.invoke(dynamicObject);
        } catch (ClassNotFoundException e) {
            System.err.println("Class not found: " + e.getMessage());
        } catch (Exception e) {
            System.err.println("Error: " + e.getMessage());
        }
    }
}

上述代码中的关键步骤包括：

使用Class.forName("DynamicClass")通过类名加载DynamicClass类。
使用反射创建DynamicClass类的实例。
使用反射获取并调用hello()方法。

自定义类加载器

前面介绍到，类加载的双亲委派模型，是推荐模型，在loadClass中实现的，并不是必须使用的模型。我们可以通过自定义类加载器，直接加载我们需要的Java类，而不委托给父类加载器。

1610974421802017548

如上图所示，我们有自定义的类加载器MyClassLoader，用来加载类MyClass，则在JVM中，会存在上面三类引用（上图忽略这三种类型对象对其他的对象的引用）。如果我们将左边的三个引用变量，均设置为null，那么此时，已经加载的MyClass将会被卸载。

自定义类加载器允许您编写自己的类加载逻辑，从外部源加载类字节码。
继承java.lang.ClassLoader类，覆盖loadClass()方法实现类的加载。
适用于特定的应用程序需求，例如插件系统。
优点：灵活性高，可以实现自定义加载逻辑。
缺点：需要小心处理类加载的双亲委派模型，容易引入类加载冲突。

例子:

package DynamicLoadingOfClasses;

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;

public class CustomClassLoader extends ClassLoader {
    private final String classFilePath;

    public CustomClassLoader(String classFilePath, ClassLoader parent) {
        super(parent);
        this.classFilePath = classFilePath;
    }

    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        try {
            // 读取类文件的字节码
            byte[] classData = loadClassData(name);
            // 使用defineClass方法加载类
            return defineClass(name, classData, 0, classData.length);
        } catch (IOException e) {
            throw new ClassNotFoundException("Class not found: " + name, e);
        }
    }

    private byte[] loadClassData(String className) throws IOException {
        Path path = Paths.get(classFilePath, className.replace('.', '/') + ".class");
        return Files.readAllBytes(path);
    }

    public static void main(String[] args) {
        String classFilePath = "D:\\语言学习\\java学习\\学习源代码\\learn\\out\\production\\learn\\DynamicLoadingOfClasses"; // 替换为类文件所在的目录
        CustomClassLoader customClassLoader = new CustomClassLoader(classFilePath, ClassLoader.getSystemClassLoader());

        try {
            // 加载DynamicClass
            Class<?> dynamicClass = customClassLoader.loadClass("DynamicLoadingOfClasses.DynamicClass");

            // 创建类的实例
            Object dynamicObject = dynamicClass.getDeclaredConstructor().newInstance();

            // 调用类的方法
            dynamicClass.getMethod("hello").invoke(dynamicObject);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

在上述示例中：

CustomClassLoader是自定义的类加载器，它继承自ClassLoader类，并实现了findClass方法，用于加载类字节码。
loadClassData 方法用于读取类文件的字节码。
main方法演示了如何使用自定义类加载器加载DynamicClass类，创建实例并调用其中的方法。

URLClassLoader

利用 URLClassLoader 加载远程 class 文件

URLClassLoader 实际上是我们平时默认使用的 AppClassLoader 的父类，所以，我们解释 URLClassLoader 的工作过程实际上就是在解释默认的 Java 类加载器的工作流程。

正常情况下，Java会根据配置项 sun.boot.class.path 和 java.class.path 中列举到的基础路径（这些路径是经过处理后的 java.net.URL 类）来寻找.class文件来加载，而这个基础路径有分为三种情况：

URL未以斜杠 / 结尾，则认为是一个JAR文件，使用 JarLoader 来寻找类，即为在Jar包中寻找.class文件
URL以斜杠 / 结尾，且协议名是 file ，则使用 FileLoader 来寻找类，即为在本地文件系统中寻找.class文件
URL以斜杠 / 结尾，且协议名不是 file ，则使用最基础的 Loader 来寻找类。

我们正常开发的时候通常遇到的是前两者，那什么时候才会出现使用 Loader 寻找类的情况呢？当然是非 file 协议的情况下，最常见的就是 http 协议。

先简单来看看前两种情况

file 协议

我们在目录下新建一个 Calc.java 的文件。

import java.io.IOException;

// URLClassLoader 的 file 协议
public class Calc {
    static {
        try {
            Runtime.getRuntime().exec("calc");
        } catch (IOException e){
            e.printStackTrace();
        }
    }
}

接着，我们编写 URLClassLoader 的启动类

package DynamicLoadingOfClasses;

import java.net.URL;
import java.net.URLClassLoader;

public class FileClassLoader {
    public static void main(String[] args) throws Exception {
        URLClassLoader urlClassLoader = new URLClassLoader
                (new URL[]{new URL("file:///D:\\语言学习\\java学习\\学习源代码\\learn\\src")});
        Class calc = urlClassLoader.loadClass("Calc");
        calc.newInstance();
    }
}

file+jar 协议

先将我们之前的 class 文件打包一下，打包为 jar 文件。

去到源 .class 文件下，别去复制的地方，运行命令

1	jar -cvf Calc.jar Clac.class

package DynamicLoadingOfClasses;

import java.net.URL;
import java.net.URLClassLoader;

public class FAJClassLoader {
    public static void main(String[] args) throws Exception{
        URLClassLoader urlClassLoader = new URLClassLoader(new URL[]{new URL("jar:file:///D:\\语言学习\\java学习\\学习源代码\\learn\\out\\production\\learn\\Calc.jar!/")});
        Class calc = urlClassLoader.loadClass("Calc");
        calc.newInstance();

    }
}

HTTP 协议

在 Calc.class 文件目录下执行 python3 -m http.server 9999，起一个 http 服务。

package DynamicLoadingOfClasses;

import java.net.URL;
import java.net.URLClassLoader;

public class HTTPClassLoader {
    public static void main(String[] args) throws Exception{
        URLClassLoader urlClassLoader = new URLClassLoader(new URL[]{new URL("http://127.0.0.1:9999")});
        Class calc = urlClassLoader.loadClass("Calc");
        calc.newInstance();
    }
}

HTTP协议也可以加载jar包

ClassLoader#defineClass

利用ClassLoader#defineClass直接加载字节码

我们认识到了如何利用URLClassLoader加载远程class文件，也就是字节码。其实，不管是加载远程class文件，还是本地的class或jar文件，Java都经历的是下面这三个方法调用

其中：

loadClass 的作用是从已加载的类缓存、父加载器等位置寻找类（这里实际上是双亲委派机制），在前面没有找到的情况下，执行 findClass
findClass 的作用是根据基础URL指定的方式来加载类的字节码，就像上一节中说到的，可能会在本地文件系统、jar包或远程http服务器上读取字节码，然后交给 defineClass
defineClass 的作用是处理前面传入的字节码，将其处理成真正的Java类所以可见，真正核心的部分其实是 defineClass ，他决定了如何将一段字节流转变成一个Java类，Java 默认的 ClassLoader#defineClass 是一个native方法，逻辑在JVM的C语言代码中。

进 ClassLoader类当中，去看一看 DefineClass 是怎么被调用的。

如果类名被找到了则

解释一下 defineClass

name为类名，b为字节码数组，off为偏移量，len为字节码数组的长度。

因为系统的 ClassLoader#defineClass 是一个保护属性，所以我们无法直接在外部访问。因此可以反射调用 defineClass() 方法进行字节码的加载，然后实例化之后即可弹 shell

演示如何让系统的 defineClass 来直接加载字节码：

package DynamicLoadingOfClasses;

import java.lang.reflect.Method;
import java.util.Base64;
public class HelloDefineClass {
    public static void main(String[] args) throws Exception {
        Method defineClass =
                ClassLoader.class.getDeclaredMethod("defineClass", String.class,
                        byte[].class, int.class, int.class);
        defineClass.setAccessible(true);
        byte[] code =
                Base64.getDecoder().decode("yv66vgAAADQAGwoABgANCQAOAA8IABAKABEAEgcAEwcAFAEABjxpbml0PgEAAygpVgEABENvZGUBAA9MaW5lTnVtYmVyVGFibGUBAApTb3VyY2VGaWxlAQAKSGVsbG8uamF2YQwABwAIBwAVDAAWABcBAAtIZWxsbyBXb3JsZAcAGAwAGQAaAQAFSGVsbG8BABBqYXZhL2xhbmcvT2JqZWN0AQAQamF2YS9sYW5nL1N5c3RlbQEAA291dAEAFUxqYXZhL2lvL1ByaW50U3RyZWFtOwEAE2phdmEvaW8vUHJpbnRTdHJlYW0BAAdwcmludGxuAQAVKExqYXZhL2xhbmcvU3RyaW5nOylWACEABQAGAAAAAAABAAEABwAIAAEACQAAAC0AAgABAAAADSq3AAGyAAISA7YABLEAAAABAAoAAAAOAAMAAAACAAQABAAMAAUAAQALAAAAAgAM");
                        Class hello =
                                (Class)defineClass.invoke(ClassLoader.getSystemClassLoader(), "Hello", code,
                                        0, code.length);
        hello.newInstance();
    }
}

反射设置：

从ClassLoader类中获取defineClass方法，使用反射实现。
setAccessible(true)允许访问defineClass方法，该方法通常是不可访问的。

Base64解码：

使用Base64.getDecoder()解码提供的base64编码的字符串。

动态类定义：

调用defineClass方法以使用解码后的字节码定义类”Hello”。
将结果的Class对象赋给变量hello

注意一点，在 defineClass 被调用的时候，类对象是不会被初始化的，只有这个对象显式地调用其构造函数，初始化代码才能被执行。而且，即使我们将初始化代码放在类的static块中，在 defineClass 时也无法被直接调用到。所以，如果我们要使用 defineClass 在目标机器上执行任意代码，需要想办法调用构造函数。

这里，因为系统的 ClassLoader#defineClass 是一个保护属性，所以我们无法直接在外部访问，不得不使用反射的形式来调用。在实际场景中，因为defineClass方法作用域是不开放的，所以攻击者很少能直接利用到它，但它却是我们常用的一个攻击链 TemplatesImpl 的基石。

TemplatesImpl

虽然大部分上层开发者不会直接使用到defineClass方法，但是Java底层还是有一些类用到了它，这就是 TemplatesImpl 。

com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl 这个类中定义了一个内部类 TransletClassLoader

static final class TransletClassLoader extends ClassLoader {
    private final Map<String,Class> _loadedExternalExtensionFunctions;

     TransletClassLoader(ClassLoader parent) {
         super(parent);
        _loadedExternalExtensionFunctions = null;
    }

    TransletClassLoader(ClassLoader parent,Map<String, Class> mapEF) {
        super(parent);
        _loadedExternalExtensionFunctions = mapEF;
    }

    public Class<?> loadClass(String name) throws ClassNotFoundException {
        Class<?> ret = null;
        // The _loadedExternalExtensionFunctions will be empty when the
        // SecurityManager is not set and the FSP is turned off
        if (_loadedExternalExtensionFunctions != null) {
            ret = _loadedExternalExtensionFunctions.get(name);
        }
        if (ret == null) {
            ret = super.loadClass(name);
        }
        return ret;
     }

    /**
     * Access to final protected superclass member from outer class.
     */
    Class defineClass(final byte[] b) {
        return defineClass(null, b, 0, b.length);
    }
}

可以看到在TransletClassLoader中的defineClass调用了此方法

再往上TemplatesImpl的defineTransletClasses方法

再往上TemplatesImpl的getTransletInstance方法

再往上TemplatesImpl的newTransformer方法，此时已经是public方法了外面可以直接调用

调用链如下

1 2	TemplatesImpl#newTransformer() ->TemplatesImpl#getTransletInstance() -> TemplatesImpl#defineTransletClasses() ->TransletClassLoader#defineClass()

看个例子：

HelloTemplateImpl.java

package DynamicLoadingOfClasses;


import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
import com.sun.org.apache.xalan.internal.xsltc.trax.TransformerFactoryImpl;

import java.lang.reflect.Field;
import java.util.Base64;
public class HelloTemplateImpl{

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

    byte[] code =
            Base64.getDecoder().decode("yv66vgAAADQAIQoABgASCQATABQIABUKABYAFwcAGAcAGQEACXRyYW5zZm9ybQEAcihMY29tL3N1bi9vcmcvYXBhY2hlL3hhbGFuL2ludGVybmFsL3hzbHRjL0RPTTtbTGNvbS9zdW4vb3JnL2FwYWNoZS94bWwvaW50ZXJuYWwvc2VyaWFsaXplci9TZXJpYWxpemF0aW9uSGFuZGxlcjspVgEABENvZGUBAA9MaW5lTnVtYmVyVGFibGUBAApFeGNlcHRpb25zBwAaAQCmKExjb20vc3VuL29yZy9hcGFjaGUveGFsYW4vaW50ZXJuYWwveHNsdGMvRE9NO0xjb20vc3VuL29yZy9hcGFjaGUveG1sL2ludGVybmFsL2R0bS9EVE1BeGlzSXRlcmF0b3I7TGNvbS9zdW4vb3JnL2FwYWNoZS94bWwvaW50ZXJuYWwvc2VyaWFsaXplci9TZXJpYWxpemF0aW9uSGFuZGxlcjspVgEABjxpbml0PgEAAygpVgEAClNvdXJjZUZpbGUBABdIZWxsb1RlbXBsYXRlc0ltcGwuamF2YQwADgAPBwAbDAAcAB0BABNIZWxsbyBUZW1wbGF0ZXNJbXBsBwAeDAAfACABABJIZWxsb1RlbXBsYXRlc0ltcGwBAEBjb20vc3VuL29yZy9hcGFjaGUveGFsYW4vaW50ZXJuYWwveHNsdGMvcnVudGltZS9BYnN0cmFjdFRyYW5zbGV0AQA5Y29tL3N1bi9vcmcvYXBhY2hlL3hhbGFuL2ludGVybmFsL3hzbHRjL1RyYW5zbGV0RXhjZXB0aW9uAQAQamF2YS9sYW5nL1N5c3RlbQEAA291dAEAFUxqYXZhL2lvL1ByaW50U3RyZWFtOwEAE2phdmEvaW8vUHJpbnRTdHJlYW0BAAdwcmludGxuAQAVKExqYXZhL2xhbmcvU3RyaW5nOylWACEABQAGAAAAAAADAAEABwAIAAIACQAAABkAAAADAAAAAbEAAAABAAoAAAAGAAEAAAAIAAsAAAAEAAEADAABAAcADQACAAkAAAAZAAAABAAAAAGxAAAAAQAKAAAABgABAAAACgALAAAABAABAAwAAQAOAA8AAQAJAAAALQACAAEAAAANKrcAAbIAAhIDtgAEsQAAAAEACgAAAA4AAwAAAA0ABAAOAAwADwABABAAAAACABE=");
    TemplatesImpl obj = new TemplatesImpl();
    setFieldValue(obj, "_bytecodes", new byte[][]{code});
    setFieldValue(obj, "_name", "HelloTemplatesImpl");
    setFieldValue(obj, "_tfactory", new TransformerFactoryImpl());
    obj.newTransformer();
}

public static void setFieldValue(Object obj, String fieldName, Object value) throws Exception {
    Field field = obj.getClass().getDeclaredField(fieldName);
    field.setAccessible(true);
    field.set(obj, value);
}
}

其中， setFieldValue 方法用来设置私有属性，可见，这里我设置了三个属性： _bytecodes 、 _name 和 _tfactory 。 _bytecodes 是由字节码组成的数组； _name 可以是任意字符串，只要不为null即可； _tfactory 需要是一个 TransformerFactoryImpl 对象，因为 TemplatesImpl#defineTransletClasses() 方法里有调用到 _tfactory.getExternalExtensionsMap() ，如果是null会出错。另外，值得注意的是， TemplatesImpl 中对加载的字节码是有一定要求的：这个字节码对应的类必须是 com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet 的子类。所以我们需要构造一个特殊的类HelloTemplatesImpl.java

package DynamicLoadingOfClasses;

import com.sun.org.apache.xalan.internal.xsltc.DOM;
import com.sun.org.apache.xalan.internal.xsltc.TransletException;
import com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet;
import com.sun.org.apache.xml.internal.dtm.DTMAxisIterator;
import com.sun.org.apache.xml.internal.serializer.SerializationHandler;
public class HelloTemplatesImpl extends AbstractTranslet {
    public void transform(DOM document, SerializationHandler[] handlers)
            throws TransletException {}
    public void transform(DOM document, DTMAxisIterator iterator,
                          SerializationHandler handler) throws TransletException {}
    public HelloTemplatesImpl() {
        super();
        System.out.println("Hello TemplatesImpl");
    }
}

它继承了 AbstractTranslet 类，并在构造函数里插入Hello的输出。将其编译成字节码，即可被 TemplatesImpl 执行了：

在HelloTemplatesImpl.java里添加方法然后在setFieldValue(obj, "_name", "方法名");修改方法名即可执行恶意命令。

在多个Java反序列化利用链，以及fastjson、jackson的漏洞中，都曾出现过 TemplatesImpl 的身影，以后的学习还要多多注意噢。

利用BCEL ClassLoader加载字节码

BCEL的全名应该是Apache Commons BCEL，属于Apache Commons项目下的一个子项目，但其因为被Apache Xalan所使用，而Apache Xalan又是Java内部对于JAXP的实现，所以BCEL也被包含在了JDK的原生库中。BCEL ClassLoader在Fastjson等漏洞的利用链构造时都有被用到，其实这个类和前面的 TemplatesImpl 都出自于同一个第三方库。但是在Java 8u251的更新中，这个ClassLoader被移除了，所以就先不学习了，如果以后遇到再学习，毕竟太久远了。