【Java技术专题】「攻破技术盲区」攻破Java技术盲点之unsafe类的使用指南(打破Java的安全管控— sun.misc.unsafe)

简介: 【Java技术专题】「攻破技术盲区」攻破Java技术盲点之unsafe类的使用指南(打破Java的安全管控— sun.misc.unsafe)

打破Java的安全管控

Java是一种安全而强大的开发工具,它能有效地防止许多低级错误,特别是与内存管理相关的错误。然而,在某些情况下,Unsafe类可以被用于一些高级开发需求,例如在底层内存操作和性能优化方面。Unsafe类确实具有许多强大的功能,如下图所示:

*Unsafe类属于sun. API,但并不是J2SE的官方一部分,所以你可能很难找到官方文档进行参考,在开发过程中,我们建议开发者谨慎使用Unsafe类,并遵循Java的最佳实践。尽可能地使用官方支持的API和框架来完成开发任务。这样可以确保代码的安全性和可维护性,并降低潜在错误的风险。**。

关于Unsafe的编程建议

通过使用Unsafe类,开发人员可以直接操作内存,从而实现一些高级功能和性能优化。但是,使用Unsafe类需要非常谨慎,因为它可以绕过Java语言的安全机制,可能导致严重的安全漏洞和内存错误。为了确保安全性和可靠性,开发人员应该遵循Java的最佳实践,并尽量避免使用Unsafe类。

实例化Unsafe后门对象

我们来看一下sun.misc.Unsafe类的源码,如下图所示。 如果尝试创建sun.misc.Unsafe类的实例,是不被允许的,主要基于以下两个原因:

  1. Unsafe类的构造函数是私有的,无法直接实例化;
  2. 虽然Unsafe类提供了静态的getUnsafe()方法,但如果尝试调用Unsafe.getUnsafe(),会导致SecurityException异常。这是因为只有由JDK信任的类才能实例化Unsafe类。
  3. 然而,总会存在一些变通的解决办法,其中一个简单的方式是利用反射进行实例化,具体示例代码如下所示:

java

复制代码

Field f = Unsafe.class.getDeclaredField("theUnsafe"); //Internal reference  
f.setAccessible(true);  
Unsafe unsafe = (Unsafe) f.get(null);

需要注意的是,IDE(如Eclipse)对于这样的用法可能会报错。不过,不用担心,你可以直接运行代码,它们应该可以正常执行,现在进入主题,使用这个对象我们可以做如下“有趣的”事情。

使用sun.misc.Unsafe

首先,让我们创建一个User类作为我们测试Unsafe操作的目标实体。

java

复制代码

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安全检查等底层操作。即使构造函数是私有的,我们也可以使用这个方法来创建实例。

java

复制代码

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()方法可以绕过构造函数的限制,但这意味着我们无法执行构造函数中的初始化逻辑。因此,必须谨慎使用此方法,并确保正确地初始化创建的对象。

单例模式处理

对于喜欢使用单例模式的程序员来说,这种方式可能会让他们感到头疼,因为它绕过了阻止此类调用的机制。让我们看一个实例。

java

复制代码

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函数将原始对象的内存数据复制到新创建的对象中。

java

复制代码

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,以使其不再被引用,从而容易被垃圾收集器回收。

  • 问题分析:在将引用设为null到垃圾收集器实际回收之间的时间段内,该字符串可能仍存在于字符串池中。在这段时间内,虽然机会很小,但仍有可能通过复杂的攻击方式读取到内存区域并获取密码。
  • 解决方案:为了解决这个问题,建议使用char[]数组来存储密码。使用完毕后,你可以迭代处理当前数组,修改/清空这些字符,从而防止密码被泄露。

使用Unsafe类—示例代码

当处理敏感数据如密码时,使用char[]数组是一种更安全的方式。以下是一个完善的案例,演示了如何使用char[]数组来存储和处理密码:

java

复制代码

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类动态加载和创建类:

java

复制代码

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表示数组长度的最大值。如果你想创建一个非常大的数组,可以通过直接分配内存来实现。以下示例演示了如何创建一个分配了连续内存(数组)的示例,其容量为最大容量的两倍:

java

复制代码

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内存管理系统,需要谨慎处理,并且仅在特定的情况下才应使用。

相关文章
|
4天前
|
自然语言处理 Java API
Java 8的Stream API和Optional类:概念与实战应用
【5月更文挑战第17天】Java 8引入了许多重要的新特性,其中Stream API和Optional类是最引人注目的两个。这些特性不仅简化了集合操作,还提供了更好的方式来处理可能为空的情况,从而提高了代码的健壮性和可读性。
26 7
|
4天前
|
XML Java API
你必须掌握的 21 个 Java 核心技术!,千峰Java
你必须掌握的 21 个 Java 核心技术!,千峰Java
|
1天前
|
监控 NoSQL Java
java云MES 系统源码Java+ springboot+ mysql 一款基于云计算技术的企业级生产管理系统
MES系统是生产企业对制造执行系统实施的重点在智能制造执行管理领域,而MES系统特点中的可伸缩、信息精确、开放、承接、安全等也传递出:MES在此管理领域中无可替代的“王者之尊”。MES制造执行系统特点集可伸缩性、精确性、开放性、承接性、经济性与安全性于一体,帮助企业解决生产中遇到的实际问题,降低运营成本,快速适应企业不断的制造执行管理需求,使得企业已有基础设施与一切可用资源实现高度集成,提升企业投资的有效性。
29 5
|
2天前
|
安全 Java 容器
Java一分钟之-并发编程:线程安全的集合类
【5月更文挑战第19天】Java提供线程安全集合类以解决并发环境中的数据一致性问题。例如,Vector是线程安全但效率低;可以使用Collections.synchronizedXxx将ArrayList或HashMap同步;ConcurrentHashMap是高效线程安全的映射;CopyOnWriteArrayList和CopyOnWriteArraySet适合读多写少场景;LinkedBlockingQueue是生产者-消费者模型中的线程安全队列。注意,过度同步可能影响性能,应尽量减少共享状态并利用并发工具类。
17 2
|
3天前
|
监控 数据可视化 Java
【JAVA】分布式链路追踪技术概论
skywalking拥有更加的强大和细粒度的图形监控界面。
14 2
|
4天前
|
Java 关系型数据库 MySQL
Java技术探索中的实践与思考
Java的跨平台、自动内存管理和丰富的类库使其备受欢迎。通过构建一个使用Spring Boot、MySQL和Thymeleaf的简易博客系统,展示了Java技术栈的应用。实践中,强调了技术选型、面向对象设计、安全性、性能优化和持续学习的重要性。
|
1天前
|
安全 Java 程序员
深入理解Java并发编程:线程安全与性能优化
【5月更文挑战第20天】本文将深入探讨Java并发编程的核心概念,包括线程安全和性能优化。我们将详细解析synchronized关键字、ReentrantLock类以及java.util.concurrent包中的高级工具类,如Semaphore、CountDownLatch和CyclicBarrier等。通过实例演示如何使用这些工具来提高多线程程序的性能和可靠性。
|
1天前
|
安全 算法 Java
深入理解Java并发编程:线程安全与性能优化
【5月更文挑战第20天】 在多核处理器日益普及的今天,并发编程成为了软件开发中不可忽视的重要话题。Java语言提供了丰富的并发工具和机制来帮助开发者构建高效且线程安全的应用程序。本文将探讨Java并发的核心概念,包括线程同步、锁机制、以及如何通过这些工具实现性能优化。我们将透过实例分析,揭示并发编程中的常见问题,并展示如何利用现代Java API来解决这些问题。
|
1天前
|
安全 Java 开发者
深入理解Java并发编程:线程安全与性能优化
【5月更文挑战第20天】在Java并发编程中,线程安全和性能优化是两个关键要素。本文将深入探讨Java并发编程的基本概念、线程安全的实现方法以及性能优化技巧。通过分析同步机制、锁优化、无锁数据结构和并发工具类的使用,我们将了解如何在保证线程安全的前提下,提高程序的性能。
|
1天前
|
安全 算法 Java
深入理解Java并发编程:线程安全与性能优化
【5月更文挑战第20天】 在Java开发中,正确处理并发问题对于确保应用的稳定性和提高性能至关重要。本文将深入探讨Java并发编程的核心概念——线程安全,以及如何通过各种技术和策略实现它,同时保持甚至提升系统性能。我们将分析并发问题的根源,包括共享资源的竞争条件、死锁以及线程活性问题,并探索解决方案如同步机制、锁优化、无锁数据结构和并发工具类等。文章旨在为开发者提供一个清晰的指南,帮助他们在编写多线程应用时做出明智的决策,确保应用的高效和稳定运行。