Java学习

jar包的签名和认证：hash密钥附加在jar包
策略文件：java.security.Policy实现。通过密钥对对文件，代码库，代码来源设置权限
保护域：类装载器封装类的代码来源和签名者，为CodeSource对象。将策略文件读取为Policy对象，并集合。那么保护域就是形容class，permission，codeSource的一个对象

类加载机制

将类文件到虚拟机能识别利用的过程，虚拟机能直接使用的类型：java.lang,class

1）装载

先查找和导入class文件类加载器：常见ClassLoader。原则：使用双亲委派机制>>双亲委派机制不同的类加载器负责加载不同区域的类文件

如Bootstrap ClassLoader负责加载¥Java_HOME中jre/lib/rt.jar里所有的class文件等

如Extension ClassLoader负责加载java平台扩展功能的一些jar包

如Extension ClassLoader负责加载java平台扩展功能的一些jar包

如App ClassLoader负责加载classpath中指定的jar包

加载器层树：（由高到低，由父到子，但不是继承关系，而是组合关系）

Bootstrap ClassLoader

Extension ClassLoader

App ClassLoader

User ClassLoader （用户自定义加载器）

双亲委派机制就是自定义类由顶级父类加载器判断是否能加载，如果不能，则由顶级的下一级加载。保证只有能加载其的最高级加载器加载

实现方法：重写findClass方法

通常情况下，自定义的class类都是在AppClassLoader加载器层上

2）链接

验证

保证加载类的正确性

准备

为类的静态变量分配内存

解析

类中符号引用转为直接引用

public static a=3; //令a=0

3）初始化

对类的静态变量，静态代码块进行初始化

//令上面的ａ=3

4）运行

class->变量常量方法->jvm内存的分配

java类动态加载方式

显式

java反射（下一章更新）

反射机制：在运行状态中，可以知道类的所有属性和方法，对于对象可以动态调用方法和属性

反射就是把类中的成分映射成一个个对象

Class.forName会初始化类的属性和方法

ClassLoader

loadClass()方法不会初始化类方法

ClassLoader加载机制

调用 public Class<?> loadClass(String name) 方法加载类

调用findLoadedClass方法检查类是否初始化，若已则返回类对象

若无法加载，则调用自身findClass方法，通过双亲委派模型不断重写findClass方法直到子加载器，用defineClass把字节码转换成Class。若直到用户自定义加载器都无法实现加载，则返回加载失败。

如果loadClass的reslove参数为1，则调用resolveClass方法链接类。默认为0.

最后返回虚拟机加载后的java.lang.Class对象

自定义类加载器

：通过java.lang.ClassLoadera

使用自定义类加载器重写findClass方法，在调用defineClass方法时传入类的字节码向JVM中定义此类，通过反射机制调用类中方法

例如此例：

package com.anbai.sec.classloader;
//准备重写
import java.lang.reflect.Method;
//使用反射机制

public class TestClassLoader extends ClassLoader {

    // TestHelloWorld类名
    private static String testClassName = "com.anbai.sec.classloader.TestHelloWorld";

    // TestHelloWorld类字节码
    private static byte[] testClassBytes = 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(testClassName)) { //判断name是否和testClassName相等
            // 调用JVM的native方法定义TestHelloWorld类
            return defineClass(testClassName, testClassBytes, 0, testClassBytes.length);
        }

        return super.findClass(name);//指向父类
    }

    public static void main(String[] args) {
        // 创建自定义的类加载器
        TestClassLoader loader = new TestClassLoader();

        try {
            // 使用自定义的类加载器加载TestHelloWorld类
            Class testClass = loader.loadClass(testClassName);

            // 反射创建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();
        }
    }

}

//说实话我现在还看不大懂哈。。。

自定义类字节码可绕过rasp，或者加密

URLClassLoader

远程执行资源。在payload和webshell中可以利用来加载远程jar实现rce

类名.class

2. Class.forName("全类名")

3. classLoader.loadClass("类名")

String className = 'java.lang.HelloWorld';
Class exampleClassName1 = Class.forName(className);
Class exampleClassName2 =java.lang.HelloWorld.class;
Class exampleClassName3 =ClassLoader.getSystemClassLoader().loadClass(classname);

如果在知道对象的情况下可以通过对象返回其类

Class exampleClassName4=ObjectName.getClass();

获取数组类型Class对象需要用JNI描述符

[D //相当于double[].class

[[Ljava.lang.String; //相当于string[][].class

当反射调用内部类时候需要用$代替.

如，调用com.anbai.Test类中的内部类Hello

则 com.anbai,Test$Hello

反射java.lang.Runtime

原理：java.lang,Runtime中存在exec，Runtime类的（）构造方法

反射Runtime执行本地命令代码：

//先通过反射获取Runtime类对象
Class runtimeClass1 = Class.forName('java.lang.Runtime');

//获取构造方法
//java.lang.Class.getDeclaredConstructor() 方法返回一个Constructor对象
Constructor constructor = runtimeClass1.getDeclaredConstructor();

//由于Runtime的构造方法时private权限，需要用反射方法修改constructor的访问权限
constructor.setAccessible(true)
/*备注1
*/

//创建Runtime类实例，这里建议使用newInstance()方法创建

备注1:《getConstructor()与getDeclaredConstructor()方法的区别及setAccessible()方法的作用(超详细)》https://blog.csdn.net/iwlnner/article/details/99674547?utm_source=app&app_version=4.5.8

具体两者区别就是getConstructor无法获取到私有方法，而前者可以通过反射获取到私有方法

备注2:https://www.cnblogs.com/yunger/p/5793669.html

反射调用类方法

获取当前类所有方法

Method[] methods = clazz.getDeclaredMethods();

获取当前类指定的方法

Method method = clazz.getDeclaredMethod("MethodName");

getMethod可以获取到当前类和父类所有public方法

getDeclaredMethed可以获取到当前类的所有方法

反射调用方法：Method的invoke方法

method.invoke(方法实例对象，方法参数值)

如果调用static方法第一个参数可以null

反射调用成员变量

获取当前类的所有成员变量：

Field fields = clazz.getDeclaredFields();

获取当前类指定的成员变量：

Field field = clazz.getDeclaredField("VarName");

同样有getField和getDeclaredMethod的区别

获取成员变量值：

Object obj = field.get(类实例对象);

修改成员变量值：

field.set(类实例对象，修改后值);

field.setAccessible(true)能够修改成员变量访问权限

而final修饰的成员变量，需要先修改方法。

sum.misc.Unsafe

反射可调用的java底层API

public final class Unsafe
    private static final Unsafe theUnsafe;

由此可知Unsafe类不可继承，不可new

(var0.getClassLoader() != null)

由之前的Bootstrap Classloader返回null可以调用

反射获取Unsafe类

获取成员变量值

// 反射获取Unsafe的theUnsafe成员变量
Field theUnsafeField = Unsafe.class.getDeclaredField("theUnsafe");

// 反射设置theUnsafe访问权限
theUnsafeField.setAccessible(true);

// 反射获取theUnsafe成员变量值
Unsafe unsafe = (Unsafe) theUnsafeField.get(null);

获取Unsafe对象

// 获取Unsafe无参构造方法
Constructor constructor = Unsafe.class.getDeclaredConstructor();

// 修改构造方法访问权限
constructor.setAccessible(true);

// 反射创建Unsafe类实例，等价于 Unsafe unsafe1 = new Unsafe();
Unsafe unsafe1 = (Unsafe) constructor.newInstance();

allocateInstance无视构造方法创建类实例

当反射不能（被限制）用构造方法创建某类实例，Unsafe的allocateInstance方法可以绕过限制

// 使用Unsafe创建UnSafeTest类实例
UnSafeTest test = (UnSafeTest) unsafe1.allocateInstance(UnSafeTest.class);

defineClass直接调用JVM创建类对象

ClassLoader被限制的情况下，使用Unsafe的defineClass向JVM中注册一个类

// 使用Unsafe向JVM中注册com.anbai.sec.classloader.TestHelloWorld类
Class helloWorldClass = unsafe1.defineClass(TEST_CLASS_NAME, TEST_CLASS_BYTES, 0, TEST_CLASS_BYTES.length);

Matou Jin

概念知识补充：