Question

标准的字节码文件是可以被反编译：

但我们可以对User.class文件进行加密：

package _day05._01自定义类加载器;


import java.io.*;

/**
 * 加密工具类，对文件进行加密（对每个字节进行异或运算）。
 * 异或运算的性质：一个数与一个基数异或两次后保持不变
 * 例：
 * a2 = a1^base
 * a3 = a2^base
 * 在执行两次异或后 a1和a3是一样的
 *
 * @Auther: TJD
 * @Date: 2020-02-11
 * @DESCRIPTION:
 **/
public class EncryptUtils {
    public static void main(String[] args) throws FileNotFoundException{
        File file = new File("C:\\Users\\Lenovo\\Desktop\\User.class");
        encrypt(file);
    }
    /**
     * 对指定文件进行编码（伪加密，Base64实际上是一个编码算法，并不是加密算法）
     *
     * @param file
     */
    public static void encrypt(File file) throws FileNotFoundException {
        InputStream input = null;
        OutputStream output = null;
        String originalPath = file.getPath();
        File targetFile = new File(originalPath + ".enc");
        try {
            input = new FileInputStream(file);
            output = new FileOutputStream(targetFile);
            transfer(input, output);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (input != null) {
                try {
                    input.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (output != null) {
                try {
                    output.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        //删除原文件
        file.delete();
        //将暂存文件，重命名为原来的文件名
        targetFile.renameTo(new File(originalPath));
    }

    /**
     * 将每个字节与11111111进行异或运算，模拟加密过程
     *
     * @param input
     * @param output
     * @throws IOException
     */
    public static void transfer(InputStream input, OutputStream output) throws IOException {
        int ch;
        while (-1 != (ch = input.read())) {
            //将每个字节和1111 1111 进行异或（模拟加密过程）
            ch = ch ^ 0xff;
            output.write(ch);
        }
    }
}

上述代码中我们对C:\\Users\\Lenovo\\Desktop\\User.class文件进行了加密，可以看到加密后的文件，变成了一个无法识别的文件：

也就是说，这个class文件已经不能被JDK自带的ClassLoader所加载了，我们需要自定义一个类加载器去加载它：

package _day05._01自定义类加载器;

import java.io.*;

/**
 * 自定义类加载器，在加载字节流的时候会先进行解密得到一个字节数组，然后在将其交由JDK底层代码进行类加载的后序操作
 *
 * @Auther: TJD
 * @Date: 2020-02-11
 * @DESCRIPTION:
 **/
public class MyClassLoader extends ClassLoader {

    /**
     * 类加载器加载的基本路径
     */
    private String basePath;
    /**
     * 类加载器的名称
     */
    private String name;

    public MyClassLoader(String name, String basePath) {
        this.name = name;
        this.basePath = basePath;
    }

    /**
     * 对指定的文件进行解密，然后返回解密后的字节数组
     * @param name 类的全限定名
     * @return
     */
    private byte[] decodeFile(String name) {
        byte[] data = new byte[0];
        InputStream input = null;
        ByteArrayOutputStream output = null;
        try {
            input = new FileInputStream(getClassFilePath(name));
            output = new ByteArrayOutputStream();
            //将读入的文件流进行解密，并写入缓存中
            EncryptUtils.transfer(input, output);
            data = output.toByteArray();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (input != null) {
                try {
                    input.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (output != null) {
                try {
                    output.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return data;
    }

    /**
     * 根据权限定名称获取，字节码文件的路径
     *
     * @param name
     * @return
     */
    private String getClassFilePath(String name) {
        String fileName = name.replaceAll("\\.", "\\\\");
        return basePath + fileName + ".class";
    }


    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        byte[] data = decodeFile(name);
        return super.defineClass(name, data, 0, data.length);
    }
}

使用自定义类加载器加载加密后的User.class文件：

package _day05._01自定义类加载器;

/**
 * @Auther: TJD
 * @Date: 2020-02-11
 * @DESCRIPTION:
 **/
public class Main {
    public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException {
        MyClassLoader classLoader = new MyClassLoader("My ClassLoader", "C:\\Users\\Lenovo\\Desktop\\");
        Class<?> clazz = classLoader.findClass("User");
        Object o = clazz.newInstance();
        System.out.println(o);
    }
}