JAVA Unsafe类

参考文章：https://javasec.org/javase/Unsafe/

Unsafe类源码自我认知

这个Unsafe类位于package sun.misc包中

Unsafe使用了1个接口，4个类

import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.security.ProtectionDomain;
import sun.reflect.CallerSensitive; //该为接口
import sun.reflect.Reflection;

从如下定义方式可知，该类是final类型的变量，那么也就是无法继承的！

public final class Unsafe

Unsafe定义了一堆如下属性，需要注意的是theUnsafe

private static final Unsafe theUnsafe; //这个属性保存了一个Unsafe对象，为什么呢？继续看后面
public static final int INVALID_FIELD_OFFSET = -1;
public static final int ARRAY_BOOLEAN_BASE_OFFSET;
public static final int ARRAY_BYTE_BASE_OFFSET;
public static final int ARRAY_SHORT_BASE_OFFSET;
public static final int ARRAY_CHAR_BASE_OFFSET;
public static final int ARRAY_INT_BASE_OFFSET;
public static final int ARRAY_LONG_BASE_OFFSET;
public static final int ARRAY_FLOAT_BASE_OFFSET;
public static final int ARRAY_DOUBLE_BASE_OFFSET;
public static final int ARRAY_OBJECT_BASE_OFFSET;
public static final int ARRAY_BOOLEAN_INDEX_SCALE;
public static final int ARRAY_BYTE_INDEX_SCALE;
public static final int ARRAY_SHORT_INDEX_SCALE;
public static final int ARRAY_CHAR_INDEX_SCALE;
public static final int ARRAY_INT_INDEX_SCALE;
public static final int ARRAY_LONG_INDEX_SCALE;
public static final int ARRAY_FLOAT_INDEX_SCALE;
public static final int ARRAY_DOUBLE_INDEX_SCALE;
public static final int ARRAY_OBJECT_INDEX_SCALE;
public static final int ADDRESS_SIZE;

它的构造函数是私有的，这就导致了它无法进行共有的实例化

它有一个getUnsafe方法来进行获取本身

public static Unsafe getUnsafe() {
    Class var0 = Reflection.getCallerClass();
    if (!VM.isSystemDomainLoader(var0.getClassLoader())) {
        throw new SecurityException("Unsafe");
    } else {
        return theUnsafe;
    }
}

它定义了一大堆的getter setter属性的方法，不止如下图所示的数量

我还看到了它关于操控内存的方法，如下方法

public native long allocateMemory(long var1); //分配内存
public native long reallocateMemory(long var1, long var3); //申请内存
public native void setMemory(Object var1, long var2, long var4, byte var6); //设置内存
public void setMemory(long var1, long var3, byte var5) { //设置内存
    this.setMemory((Object)null, var1, var3, var5);
}
public native void copyMemory(Object var1, long var2, Object var4, long var5, long var7);//复制内存
public void copyMemory(long var1, long var3, long var5) { //复制内存
    this.copyMemory((Object)null, var1, (Object)null, var3, var5);
}
public native void freeMemory(long var1); //释放内存

还有三个特殊的如下方法：

public native Class<?> defineClass(String var1, byte[] var2, int var3, int var4, ClassLoader var5, ProtectionDomain var6); //定义类
public native Class<?> defineAnonymousClass(Class<?> var1, byte[] var2, Object[] var3); //定义匿名类
public native Object allocateInstance(Class<?> var1) throws InstantiationException; //分配实例

静态代码块，这里就要讲为什么theUnsafe会保存一个Unsafe对象了

static {
        registerNatives();
        Reflection.registerMethodsToFilter(Unsafe.class, new String[]{"getUnsafe"});
        theUnsafe = new Unsafe(); //这里就说明了为什么theUnsafe会保存一个Unsafe对象
        ARRAY_BOOLEAN_BASE_OFFSET = theUnsafe.arrayBaseOffset(boolean[].class);
        ARRAY_BYTE_BASE_OFFSET = theUnsafe.arrayBaseOffset(byte[].class);
        ARRAY_SHORT_BASE_OFFSET = theUnsafe.arrayBaseOffset(short[].class);
        ARRAY_CHAR_BASE_OFFSET = theUnsafe.arrayBaseOffset(char[].class);
        ARRAY_INT_BASE_OFFSET = theUnsafe.arrayBaseOffset(int[].class);
        ARRAY_LONG_BASE_OFFSET = theUnsafe.arrayBaseOffset(long[].class);
        ARRAY_FLOAT_BASE_OFFSET = theUnsafe.arrayBaseOffset(float[].class);
        ARRAY_DOUBLE_BASE_OFFSET = theUnsafe.arrayBaseOffset(double[].class);
        ARRAY_OBJECT_BASE_OFFSET = theUnsafe.arrayBaseOffset(Object[].class);
        ARRAY_BOOLEAN_INDEX_SCALE = theUnsafe.arrayIndexScale(boolean[].class);
        ARRAY_BYTE_INDEX_SCALE = theUnsafe.arrayIndexScale(byte[].class);
        ARRAY_SHORT_INDEX_SCALE = theUnsafe.arrayIndexScale(short[].class);
        ARRAY_CHAR_INDEX_SCALE = theUnsafe.arrayIndexScale(char[].class);
        ARRAY_INT_INDEX_SCALE = theUnsafe.arrayIndexScale(int[].class);
        ARRAY_LONG_INDEX_SCALE = theUnsafe.arrayIndexScale(long[].class);
        ARRAY_FLOAT_INDEX_SCALE = theUnsafe.arrayIndexScale(float[].class);
        ARRAY_DOUBLE_INDEX_SCALE = theUnsafe.arrayIndexScale(double[].class);
        ARRAY_OBJECT_INDEX_SCALE = theUnsafe.arrayIndexScale(Object[].class);
        ADDRESS_SIZE = theUnsafe.addressSize();
    }

我查了下静态代码块的概念：static代码块指的是static{}包裹的代码块，且静态代码只执行一次，可以通过Class.forName("classPath")的方式唤醒代码的static代码块，但是也执行一次

我等下需要做个试验来证明是不是只有Class.forName("classPath")来唤醒static代码块还是咋的!

Unsafe类的方法学习

现在在对该类的方法进行学习：

因为上面说了，不能直接实例化，因为默认的构造方法是私有的，所以现在有两种获取该类的对象的方法

第一种：通过反射来获取该类的无参构造方法，然后进行实例化！

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

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

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

第二种：通过反射来获取该类中的属性theUnsafe，然后通过Unsafe实例化对象来接受

上面自己说做的试验的其实就是这里的问题，因为自己发现笔记中做的代码是如下代码，并且运行了是可以获取到该对象的！

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


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


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

System.out.println(unsafe.toString());

那么是不是也说明Unsafe.class操作也会触发static代码块？？？

结果如下：

关于第一个强大功能：allocateInstance，该方法可以绕过构造方法创建类实例

什么时候用到该方法呢？利用场景：开头被Hook，可以通过allocateInstace来绕过

public class UnSafeTest {
   private UnSafeTest() {
      // 假设RASP在这个构造方法中插入了Hook代码，我们可以利用Unsafe来创建类实例
      System.out.println("init...");
   }
}

那么只需要做的事情就是如下的一句话

UnSafeTest unsafetest = Unsafe对象.allocateInstace(UnSafeTest);

defineClass的妙用

什么时候用到Unsafe类中的defineClass呢？

利用场景：当ClassLoader类被限制的情况下，如果能够向JVM虚拟机注册一个类呢？通过Unsafe中的defineClass方法也是一种方法，这里自己想了下是不是不要局限于Unsafe类中，其实其他类中如果有defineClass方法的话也是可以利用的，当然自己没实战过，现在只需要记住就行了！

        //这里自己通过Unsafe类的defineClass来获取MyClassLoader包中的TestHelloWorld类，这个类就是javasec第一篇中创建的类

        //首先先获取Unsafe的类的实例，然后获取该构造器
        Constructor SafeConstructor = Unsafe.class.getDeclaredConstructor();

        //因为Unsafe构造器默认是私有的，所以还要设置权限
        SafeConstructor.setAccessible(true);

        //然后调用newIntance生成一个实例返回
        Unsafe unsafe = (Unsafe)SafeConstructor.newInstance();

        // 默认ClassLoader
        ClassLoader classLoader = ClassLoader.getSystemClassLoader();
        //默认保护域
        ProtectionDomain domain = new ProtectionDomain(
                new CodeSource(null, (Certificate[]) null), null, classLoader, null
        );

        //通过Unsafe类的defineClass来绕过ClassLoader来创建TestHelloWorld类的对象
        Class helloWorld = unsafe.defineClass(TEST_CLASS_NAME, TEST_CLASS_BYTES, 0, TEST_CLASS_BYTES.length, classLoader, domain);

        Constructor WorldConstructor = helloWorld.getDeclaredConstructor();

        TestHelloWorld testHelloWorld = (TestHelloWorld) WorldConstructor.newInstance();
        System.out.println(testHelloWorld.hello());