Java安全之【JVM类加载器】

2401_84048179

于 2024-04-15 07:51:47 发布

阅读量1k

点赞数 17

分类专栏：程序员文章标签： java 安全 jvm

本文链接：https://blog.csdn.net/2401_84048179/article/details/137763793

版权

程序员专栏收录该内容

266 篇文章 0 订阅

订阅专栏

0x03 双亲委派机制

双亲委派机制是Java类加载的核心，该机制一定程度的保证了类加载的安全性。简单来讲这个机制就是“当有载入类的需求时，类加载器会先请示父加载器帮忙载入，如果没有父加载器那么就使用BootStrapClassLoader进行加载，如果所有的父加载器都找不到对应的类，那么才由自己依照自己的搜索路径搜索类，如果还是搜索不到，则抛出ClassNotFoundException

0x1 双亲委派结构

在Java JDK中的类加载器结构如下图所示，BootstrapClassLoader为根加载器、ExtClassLoader为扩展类加载器、AppClassLoader为应用类加载器。其结构如下所示，需要注意的是他们这几个类之间的关系为依赖关系，并不是继承关系。

其中User1ClassLoader可以为应用自己设计的类加载器，并设置AppClassLoader为父加载器，这样就可以使用双亲委派机制。

0x2 代码实现

那么关于双亲委派机制代码上的实现也很简单，根据功能描述写对应的if else分支即可。一般在ClassLoader子类中

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) { }

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©;//链接已经装载的类

}

return c;

}

0x04 自定义类加载器

同一个类代码如果被不同的类加载器加载，那么在当前JVM中他们是两个不同的类。

0x1 遵循双亲委派机制

1.继承java.lang.ClassLoader

2.重写父类的findClass方法

loadClass方法已经实现了双亲委派功能，如果我们再去覆盖loadClass函数就会破坏双亲委派机制。并且JDK已经在loadClass方法中帮我们实现了ClassLoader搜索类的算法，当在loadClass方法中搜索不到类时，loadClass方法就会调用findClass方法来搜索类，所以我们只需重写该方法即可。

0x2 破坏双亲委派机制

双亲委派机制主要依赖于ClassLoader类中的loadclass函数实现逻辑，如果直接在子类中重写loadClass方法，就可以破坏双亲委派机制。目前存在的一些组件，其类加载机制不符合双亲委派也很正常。那么可能有小伙伴就很迷糊了，到底是要遵守还是要破坏呢？应该根据需求，特殊情况特殊对待，大佬们也总结过几种应用场景，梳理如下

1. Tomcat类加载机制

首先说明双亲委派机制的缺点是，当加载同个jar包不同版本库的时候，该机制无法自动选择需要版本库的jar包。特别是当Tomcat等web容器承载了多个业务之后，不能有效的加载不同版本库。为了解决这个问题，Tomcat放弃了双亲委派模型。

当时分析Shiro反序列化的时候，遇到了Tomcat的类加载器重写了loadClass函数，从而没有严格按照双亲委派机制进行类加载，这样才能实现加载多个相同类，相当于提供了一套隔离机制，为每个web容器提供一个单独的WebAppClassLoader加载器。

Tomcat加载机制简单讲，WebAppClassLoader负责加载本身的目录下的class文件，加载不到时再交给CommonClassLoader加载，这和双亲委派刚好相反。

2. OSGI模块化加载机制

不再是双亲委派的树桩结构，而是网状结构，没有固定的委派模型，只有具体使用某个package或者class时，根据package的导入导出的定义来构造bundle之间的委派和依赖。这块内容也打算单独写，vCenter部署及类加机制很大程度上依赖该技术，这里先挖个坑。

3. JDBC类加载机制

这里双亲委派的缺点是父加载器无法使用子加载器加载需要的类，这个使用场景就在JDBC中出现了。

以往JDBC的核心类在rt.jar中，由根加载器加载，然而现在核心类在不同厂商实现的jar包中，根据类加载机制，如果A类调用B类，则B类由A类的加载器加载，这也就意味着根加载器要加载jar包下的类，很显然这一操作违背了双亲委派机制。

为了让父加载器调用子加载器加载需要的类，JDBC使用了Thread.currentThread().getContextClassLoader()得到线程上下文加载器来加载Driver实现类。

0x3 加载加密字节码

为了更深入的了解ClassLoader的工作流程，打算自己写一个加载Class密文件。首先编写加解密函数，将编译好的class文件通过encryptfile函数加密。

package myclassloadertest;

import javax.crypto.Cipher;

import javax.crypto.spec.IvParameterSpec;

import javax.crypto.spec.SecretKeySpec;

import java.io.*;

public class FileUtils {

private static final int ZERO = 0;

private static final int ONE = 1;

private static String derectory ;

private static String key = “aaaabbbbccccdddd”;

private static String ivParameter = “AAAABBBBCCCCDDDD”;

public FileUtils (String path){

derectory = path;

}

public static byte[] doFile(int code, File file, String key, String ivParameterm, String filename) throws Exception {

BufferedInputStream bis = new BufferedInputStream(new FileInputStream(

file));

byte[] bytIn = new byte[(int) file.length()];

bis.read(bytIn);

bis.close();

byte[] raw = key.getBytes(“ASCII”);

SecretKeySpec skeySpec = new SecretKeySpec(raw, “AES”);

Cipher cipher = Cipher.getInstance(“AES/CBC/PKCS5Padding”);

IvParameterSpec iv = new IvParameterSpec(ivParameterm.getBytes());

if (0 == code) {

cipher.init(Cipher.ENCRYPT_MODE, skeySpec, iv);

} else if (1 == code) {

cipher.init(Cipher.DECRYPT_MODE, skeySpec, iv);

}

byte[] bytOut = cipher.doFinal(bytIn);

File outfile = new File(derectory + “/” + filename);

BufferedOutputStream bos = new BufferedOutputStream(

new FileOutputStream(outfile));

bos.write(bytOut);

bos.close();

return bytOut;

}

public static void encryptfile(File file, String key, String ivParameter, String filename) throws Exception {

doFile(ZERO, file, key, ivParameter, filename);

}

public static byte[] decryptfile(File file, String key, String ivParameter, String filename) throws Exception {

return doFile(ONE, file, key, ivParameter, filename);

}

public static byte[] loadfile(String name) throws Exception {

File file = new File(derectory + name.replace(‘.’, ‘/’) + “.class”);

return decryptfile(file, key, ivParameter, “decrypt_tmp_file”);

}

public static void main(String[] args) {

try {

File file = new File(derectory + “myclassloadertest/Test.class”);

String fileName = “myclassloadertest/TestCrypt.class”;

encryptfile(file, key, ivParameter, fileName);

} catch (Exception e) {

e.printStackTrace();

}

自己编写的classloader只需要使用其中loadfile函数就可以找到文件并自动解密。自定义ClassLoader代码如下

package myclassloadertest;

public class MyClassLoader extends ClassLoader{

private FileUtils fu;

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

ClassLoader classloader=new MyClassLoader(“mypath”);

Class<?> classx = classloader.loadClass(“myclassloadertest.Test”);

System.out.println(classx);

}

public MyClassLoader(String path){

fu = new FileUtils(path);

}

@Override

public Class<?> loadClass(String name) throws ClassNotFoundException {

Class<?> c = findLoadedClass(name);

if (c != null) {

return c;

} else {

ClassLoader parent = this.getParent();//获取父装载器

if (parent != null){

try {

c = parent.loadClass(name);//实现双亲委派机制

}catch (ClassNotFoundException x){}

}

if(c == null){

try {

byte[] classData = fu.loadfile(name);//获取字节码

c = defineClass(name,classData,0,classData.length);//加载类

return c;

} catch (Exception e) {

e.printStackTrace();

}

return c;

}

在实验的过程中要将原来的Test.java删除，这样JDK AppClassLoader就找不到Test类，从而使用FileUtils加载密文件。自定义的ClassLoader也有parent节点，这是因为在初始化加载器的时候会调用父类ClassLoader中的构造方法，该方法中包含着parent属性赋值等操作，如下图所示