打破 Java 的安全管控
Java 是一种安全而强大的开发工具，它能有效地防止许多低级错误，特别是与内存管理相关的错误。然而，在某些情况下，Unsafe 类可以被用于一些高级开发需求，例如在底层内存操作和性能优化方面。Unsafe 类确实具有许多强大的功能，如下图所示：
Unsafe 类属于 sun. API，但并不是 J2SE 的官方一部分，所以你可能很难找到官方文档进行参考，在开发过程中，我们建议开发者谨慎使用 Unsafe 类，并遵循 Java 的最佳实践。尽可能地使用官方支持的 API 和框架来完成开发任务。这样可以确保代码的安全性和可维护性，并降低潜在错误的风险。*。
关于 Unsafe 的编程建议
通过使用 Unsafe 类，开发人员可以直接操作内存，从而实现一些高级功能和性能优化。但是，使用 Unsafe 类需要非常谨慎，因为它可以绕过 Java 语言的安全机制，可能导致严重的安全漏洞和内存错误。为了确保安全性和可靠性，开发人员应该遵循 Java 的最佳实践，并尽量避免使用 Unsafe 类。
实例化 Unsafe 后门对象
我们来看一下 sun.misc.Unsafe 类的源码，如下图所示。
如果尝试创建 sun.misc.Unsafe 类的实例，是不被允许的，主要基于以下两个原因：
Unsafe 类的构造函数是私有的，无法直接实例化；
虽然 Unsafe 类提供了静态的 getUnsafe()方法，但如果尝试调用 Unsafe.getUnsafe()，会导致 SecurityException 异常。这是因为只有由 JDK 信任的类才能实例化 Unsafe 类。
然而，总会存在一些变通的解决办法，其中一个简单的方式是利用反射进行实例化，具体示例代码如下所示：
Field f = Unsafe.class.getDeclaredField("theUnsafe"); //Internal reference f.setAccessible(true); Unsafe unsafe = (Unsafe) f.get(null);
复制代码
需要注意的是，IDE（如 Eclipse）对于这样的用法可能会报错。不过，不用担心，你可以直接运行代码，它们应该可以正常执行，现在进入主题，使用这个对象我们可以做如下“有趣的”事情。
使用 sun.misc.Unsafe
首先，让我们创建一个 User 类作为我们测试 Unsafe 操作的目标实体。
public class User {
private String name; private int age;
public User(String name, int age) { this.name = name; this.age = age; }
public String getName() { return name; }
public int getAge() { return age; }
public void setName(String name) { this.name = name; }
public void setAge(int age) { this.age = age; }}
复制代码
以上是一个简单的 User 类，包含一个 name 属性和一个 age 属性，以及相应的 getter 和 setter 方法。这将作为我们接下来进行 Unsafe 操作的测试实体类。
创建实例
通过使用 Unsafe 类的 allocateInstance()方法，我们可以创建一个类的实例，而无需调用其构造函数、初始化代码、JVM 安全检查等底层操作。即使构造函数是私有的，我们也可以使用这个方法来创建实例。
public class UnsafeTest {
public static Unsafe getUnsafe(){ Field f = Unsafe.class.getDeclaredField("theUnsafe"); // Internal reference f.setAccessible(true); Unsafe unsafe = (Unsafe) f.get(null); }
public static void main(String[] args) throws NoSuchFieldException, SecurityException, Illegal ArgumentException, IllegalAccessException, InstantiationException { User user = (User ) getUnsafe().allocateInstance(User.class); System.out.println(user.getAge()); // Print 0 user.setAge(45); // Let's now set age 45 to un-initialized object System.out.println(user.getAge()); // Print 45 } }
复制代码
在上述示例中，通过调用 Unsafe 类的 allocateInstance()方法实例化了 User 类的对象。注意，我们并没有直接调用 User 类的构造函数，而是绕过了它。
注意，虽然使用 allocateInstance()方法可以绕过构造函数的限制，但这意味着我们无法执行构造函数中的初始化逻辑。因此，必须谨慎使用此方法，并确保正确地初始化创建的对象。
单例模式处理
对于喜欢使用单例模式的程序员来说，这种方式可能会让他们感到头疼，因为它绕过了阻止此类调用的机制。让我们看一个实例。
public class Singleton { // 私有化构造函数，强制使用getInstance()方法获取实例 private Singleton() { // 构造函数逻辑 }
private static Singleton instance;
// 获取单例实例的方法 public static Singleton getInstance() { if (instance == null) { try { // 使用Unsafe类的allocateInstance()方法创建实例 Unsafe unsafe = Unsafe.getUnsafe(); instance = (Singleton) unsafe.allocateInstance(Singleton.class); } catch (InstantiationException e) { e.printStackTrace(); } } return instance; } // 其他方法和属性...}
复制代码
在上述示例中，展示了如何使用 Unsafe 类的 allocateInstance()方法来创建单例模式的实例。请注意，我们绕过了私有构造函数，通过 allocateInstance()方法创建了实例。
实现浅克隆（直接获取内存的方式）
对于浅克隆的实现方法，通常是在clone()方法中调用super.clone()来完成。然而，这种方式要求对象必须实现Cloneable接口，并且在需要进行浅克隆的所有对象中都要实现clone()方法。对于一些开发者来说，这可能会带来一定的工作量和复杂性。
直接使用 copyMemory
copyMemory 函数是一种低级别的内存复制方法，它可以按字节进行复制。
确定对象的大小：首先，你需要确定要克隆的对象的大小。这可以通过计算对象的字节数来完成。
创建目标对象：使用目标对象的构造函数创建一个新的对象。这个对象将是克隆对象的副本。
使用 copyMemory 进行复制：使用 copyMemory 函数将原始对象的内存数据复制到新创建的对象中。
public class TestCloneable { private static Unsafe getUnsafeInstance() throws IllegalAccessException, NoSuchFieldException { Field theUnsafeField = Unsafe.class.getDeclaredField("theUnsafe"); theUnsafeField.setAccessible(true); return (Unsafe) theUnsafeField.get(null); } public static void main(String[] args) throws Exception { // 使用Unsafe类进行浅克隆 User originalPerson = new User("name",12); Unsafe unsafe = getUnsafeInstance(); User clonedPersonUnsafe = (User) unsafe.allocateInstance(User.class); // 获取对象的起始地址 long srcAddress = unsafe.objectFieldOffset(User.class.getDeclaredField("name")); // 获取对象的大小 int类型4个字节。 long objectSize = srcAddress + 4; // 分配新的内存空间 long clonedObjectAddress = unsafe.allocateMemory(objectSize); // 执行内存复制操作 unsafe.copyMemory(originalPerson , srcAddress, clonedPersonUnsafe , clonedObjectAddress, objectSize ); System.out.println("Cloned User (Unsafe): " + clonedPersonUnsafe); }}
复制代码
原理分析
unsafe.copyMemory() 方法是 sun.misc.Unsafe 类中用于在内存中复制数据的方法。它的参数如下：
这个方法用于在内存中直接复制数据，可以用于将一个对象的字节数据复制到另一个对象的内存位置，然后将这个对象转换为需要被克隆的对象类型。
注意，在使用 Unsafe 类进行对象克隆时，需要特别谨慎，并确保了解其带来的潜在风险。而在实际开发中，为了代码的可读性和可维护性，我们通常建议使用传统的clone()方法或者其他官方支持的克隆方式。
密码安全
开发人员通常会将密码存储在字符串中，并在应用程序中使用这些密码。使用完成后，一些聪明的程序员会将字符串引用设为null，以使其不再被引用，从而容易被垃圾收集器回收。
使用Unsafe类—示例代码
当处理敏感数据如密码时，使用 char[]数组是一种更安全的方式。以下是一个完善的案例，演示了如何使用 char[]数组来存储和处理密码：
public static void main(String[] args) throws Exception { String password = "l00k@myHor$e"; String fake = password.replaceAll(".", "?"); System.out.println("Original password: " + password); System.out.println("Fake password: " + fake); Unsafe unsafe = getUnsafeInstance(); unsafe.copyMemory(fake, 0L, null, toAddress(password), sizeOf(password)); System.out.println("Password after overwrite: " + password); System.out.println("Fake password after overwrite: " + fake);}
private static long toAddress(Object object) throws NoSuchFieldException, IllegalAccessException { Unsafe unsafe = getUnsafeInstance(); Object[] array = new Object[] { object }; long offset = unsafe.arrayBaseOffset(Object[].class); return unsafe.getLong(array, offset);}
private static int sizeOf(Object object) throws NoSuchFieldException, IllegalAccessException { Unsafe unsafe = getUnsafeInstance(); return (int) (unsafe.getAddress(toAddress(object) + 8));}
private static Unsafe getUnsafeInstance() throws NoSuchFieldException, IllegalAccessException { Field theUnsafeField = Unsafe.class.getDeclaredField("theUnsafe"); theUnsafeField.setAccessible(true); return (Unsafe) theUnsafeField.get(null);}
复制代码
运行时动态创建类
通过使用 sun.misc.Unsafe 类的 defineClass()方法，可以在运行时动态地创建类。这种方式允许我们将一个字节数组（如编译后的.class 文件）转换为一个 Java 类的实例。
下面是一个简单的示例，演示了如何通过 sun.misc.Unsafe 类动态加载和创建类：
import sun.misc.Unsafe;import java.lang.reflect.Field;public class DynamicClassCreationExample { public static void main(String[] args) throws Exception { // 获取Unsafe实例 Unsafe unsafe = getUnsafeInstance(); // 读取.class文件并保存为字节数组 byte[] classBytes = readClassBytes("DynamicClassToBeCreated.class"); // 动态创建类 Class<?> dynamicClass = unsafe.defineClass(null, classBytes, 0, classBytes.length, DynamicClassCreationExample.class.getClassLoader(), null); // 使用动态创建的类 Object instance = dynamicClass.getDeclaredConstructor().newInstance(); System.out.println(instance.getClass().getName()); // 输出：DynamicClassToBeCreated }
private static byte[] readClassBytes(String className) throws IOException { InputStream inputStream = DynamicClassCreationExample.class.getClassLoader().getResourceAsStream(className); ByteArrayOutputStream outputStream = new ByteArrayOutputStream(); byte[] buffer = new byte[1024]; int length; while ((length = inputStream.read(buffer)) != -1) { outputStream.write(buffer, 0, length); } return outputStream.toByteArray(); }
private static Unsafe getUnsafeInstance() throws IllegalAccessException, NoSuchFieldException { Field theUnsafeField = Unsafe.class.getDeclaredField("theUnsafe"); theUnsafeField.setAccessible(true); return (Unsafe) theUnsafeField.get(null); }}
复制代码
在上述示例中，我们首先获取 sun.misc.Unsafe 实例，并将编译后的.class 文件读取为字节数组。然后，使用 defineClass()方法创建一个新的类。通过调用该方法，我们可以指定类加载器、字节数组的偏移量和长度等信息来创建类。
超大数组
在 Java 中，常量 Integer.MAX_VALUE 表示数组长度的最大值。如果你想创建一个非常大的数组，可以通过直接分配内存来实现。以下示例演示了如何创建一个分配了连续内存（数组）的示例，其容量为最大容量的两倍：
import sun.misc.Unsafe;import java.lang.reflect.Field;public class LargeArrayExample { private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8; public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException { // 获取Unsafe实例 Unsafe unsafe = getUnsafeInstance(); // 计算数组长度 long arrayLength = (long) MAX_ARRAY_SIZE * 2; // 分配内存 long arrayAddress = unsafe.allocateMemory(arrayLength); System.out.println("Array allocated at address: " + arrayAddress); for (int i = 0; i < 12 ; i += blockSize) { // 获取当前块的地址 long blockAddress = arrayAddress + (i * Integer.BYTES); // 计算当前块的实际大小 long currentBlockSize = Math.min(12 - i, blockSize); // 循环添加元素到当前块 for (int j = 0; j < currentBlockSize; j++) { unsafe.putInt(blockAddress + (j * Integer.BYTES), i + j); } } } private static Unsafe getUnsafeInstance() throws NoSuchFieldException, IllegalAccessException { Field theUnsafeField = Unsafe.class.getDeclaredField("theUnsafe"); theUnsafeField.setAccessible(true); return (Unsafe) theUnsafeField.get(null); }}
复制代码
总结概括
sun.misc.Unsafe 提供了可以随意查看及修改 JVM 中运行时的数据结构，尽管这些功能在 JAVA 开发本身是不适用的。Unsafe 是一个用于研究学习 HotSpot 虚拟机非常棒的工具，因为它不需要调用 C++代码，或者需要创建即时分析的工具。然而，使用 Unsafe 类进行直接内存分配是一种非常底层和不安全的操作，绕过了 Java 内存管理系统，需要谨慎处理，并且仅在特定的情况下才应使用。
评论