sun.misc.unsafe类的使用

红太狼 2022-09-23 14:57 151阅读 0赞

本文转载自：http://blog.csdn.net/fenglibing/article/details/17138079

另一个值得看文章：http://aswang.iteye.com/blog/1741871

[Java][]是一个安全的开发工具，它阻止开发人员犯很多低级的错误，而大部份的错误都是基于内存管理方面的。如果你想搞破坏，可以使用Unsafe这个类。这个类是属于sun.\* API中的类，并且**它不是J2SE中真正的一部份**，因此你可能找不到任何的官方文档，更可悲的是，它也没有比较好的代码文档。该类是用来执行较低级别的操作的，比如获取某个属性在内存中的位置，不过一般人很少会有这样的需求。

**实例化sun.misc.Unsafe**

如果你尝试创建Unsafe类的实例，基于以下两种原因是不被允许的。

1）、Unsafe类的构造函数是私有的；

2）、虽然它有静态的getUnsafe()方法，但是如果你尝试调用Unsafe.getUnsafe()，会得到一个SecutiryException。这个类只有被JDK信任的类实例化。

但是这总会是有变通的解决办法的，一个简单的方式就是使用反射进行实例化：

**\[java\]**  [view plain][]   [copy][view plain]

[![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

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

注：IDE如Eclipse对会这样的使用报错，不过不用担心，直接运行代码就行，可以正常运行的。

（译者注：还有一种解决方案，就是将Eclipse中这种限制获取由错误，修改为警告，具体操作为将Windows->Preference...->Java->Compiler->Errors/Warnings中的"Deprecated and restricted API"，级别由Error修改为Warning就可以了）

现在进入主题，使用这个对象我们可以做如下“有趣的”事情。

**使用sun.misc.Unsafe**

**1）、突破限制创建实例**

通过allocateInstance()方法，你可以创建一个类的实例，但是却不需要调用它的构造函数、初使化代码、各种JVM安全检查以及其它的一些底层的东西。即使构造函数是私有，我们也可以通过这个方法创建它的实例。

（这个对单例模式情有独钟的程序员来说将会是一个噩梦，它们没有办法阻止这种方式调用![大笑][laugh.gif]）

看下面一个实例（注：为了配合这个主题，译者将原实例中的public构造函数修改为了私有的）：

**\[java\]**  [view plain][]   [copy][view plain]

[![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  **public** **class** UnsafeDemo \{  
2.      **public** **static** **void** main(String\[\] args) **throws** NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException, InstantiationException \{  
3.          Field f = Unsafe.**class**.getDeclaredField("theUnsafe"); // Internal reference  
4.          f.setAccessible(**true**);  
5.          Unsafe unsafe = (Unsafe) f.get(**null**);  
6.    
7.          // This creates an instance of player class without any initialization  
8.          Player p = (Player) unsafe.allocateInstance(Player.**class**);  
9.          System.out.println(p.getAge()); // Print 0  
10.   
11.         p.setAge(45); // Let's now set age 45 to un-initialized object  
12.         System.out.println(p.getAge()); // Print 45  
13.     \}  
14. \}  
15.   
16. **class** Player \{  
17.     **private** **int** age = 12;  
18.   
19.     **private** Player() \{  
20.         **this**.age = 50;  
21.     \}  
22.   
23.     **public** **int** getAge() \{  
24.         **return** **this**.age;  
25.     \}  
26.   
27.     **public** **void** setAge(**int** age) \{  
28.         **this**.age = age;  
29.     \}  
30. \}

**2）、使用直接获取内存的方式实现浅克隆**

如何实现浅克隆？在clone()\{...\}方法中调用super.clone()，对吗？这里存在的问题是首先你必须继续Cloneable接口，并且在所有你需要做浅克隆的对象中实现clone()方法，对于一个懒懒的程序员来说，这个工作量太大了。

我不推荐上面的做法而是直接使用Unsafe，我们可以仅使用几行代码就实现浅克隆，并且它可以像某些工具类一样用于任意类的克隆。

这个戏法就是把一个对象的字节码拷贝到内存的另外一个地方，然后再将这个对象转换为被克隆的对象类型。

**3）、来自黑客的密码安全**

这个好似很有趣吧？实事就是这样的。开发人员创建密码或者是保证密码到字符串中，然后在应用程序的代码中使用这些密码，使用过后，聪明的程序员会把字符串的引用设为NULL，因此它就不会被引用着并且很容易被垃圾收集器给回收掉。

但是从你将引用设为NULL到被垃圾收集器收集的这个时间段之内（原文：But from the time, you made the reference null to the time garbage collector kicks in），它是处于字符串池中的，并且在你系统中进行一个复杂的攻击（原文：And a sophisticated attack on your system），也是可以读取到你的内存区域并且获得密码，虽然机会很小，但是总是存在的。

这就是为什么建议使用char\[\]数组存放密码，当使用完过后，你可以迭代处理当前数组，修改/清空这些字符。

另外一个方式就是使用魔术类Unsafe。你可以创建另外一个和当前密码字符串具有相同长度的临时字符串，将临时密码中的每个字符都设值为"?"或者"\*"（任何字符都可以），当你完成密码的逻辑后，你只需要简单的将临时密码中的字节数组拷贝到原始的密码串中，这就是使用临时密码覆盖真实的密码。

示例代码可能会是这样：

**\[java\]**  [view plain][]   [copy][view plain]

[![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  String password = **new** String("l00k@myHor$e");  
2.  String fake = **new** String(password.replaceAll(".", "?"));  
3.  System.out.println(password); // l00k@myHor$e  
4.  System.out.println(fake); // ????????????  
5.     
6.  getUnsafe().copyMemory(fake, 0L, **null**, toAddress(password), sizeOf(password));  
7.     
8.  System.out.println(password); // ????????????  
9.  System.out.println(fake); // ????????????

运行时动态创建类

我们可以在运行时运态的创建类，例如通过编译后的.class文件，操作方式就是将.class文件读取到字节数据组中，并将其传到defineClass方法中。

**\[java\]**  [view plain][]   [copy][view plain]

[![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  //Sample code to craeet classes  
2.  **byte**\[\] classContents = getClassContent();  
3.  Class c = getUnsafe().defineClass(**null**, classContents, 0, classContents.length);  
4.  c.getMethod("a").invoke(c.newInstance(), **null**);  
5.     
6.  //Method to read .class file  
7.  **private** **static** **byte**\[\] getClassContent() **throws** Exception \{  
8.      File f = **new** File("/home/mishadoff/tmp/A.class");  
9.      FileInputStream input = **new** FileInputStream(f);  
10.     **byte**\[\] content = **new** **byte**\[(**int**)f.length()\];  
11.     input.read(content);  
12.     input.close();  
13.     **return** content;  
14. \}

**4）、超大数组**

从所周知，常量Integer.MAX\_VALUE是JAVA中数组长度的最大值，如果你想创建一个非常大的数组（虽然在通常的应用中不可能会用上），可以通过对内存进行直接分配实现。

下面这个示例将会创建分配一段连续的内存（数组），它的容易是允许最大容量的两倍。

**\[java\]**  [view plain][]   [copy][view plain]

[![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  **class** SuperArray \{  
2.      **private** **final** **static** **int** BYTE = 1;  
3.      **private** **long** size;  
4.      **private** **long** address;  
5.         
6.      **public** SuperArray(**long** size) \{  
7.          **this**.size = size;  
8.          //得到分配内存的起始地址  
9.          address = getUnsafe().allocateMemory(size \* BYTE);  
10.     \}  
11.     **public** **void** set(**long** i, **byte** value) \{  
12.         getUnsafe().putByte(address + i \* BYTE, value);  
13.     \}  
14.     **public** **int** get(**long** idx) \{  
15.         **return** getUnsafe().getByte(address + idx \* BYTE);  
16.     \}  
17.     **public** **long** size() \{  
18.         **return** size;  
19.     \}  
20. \}

应用示例

**\[java\]**  [view plain][]   [copy][view plain]

[![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  **long** SUPER\_SIZE = (**long**)Integer.MAX\_VALUE \* 2;  
2.  SuperArray array = **new** SuperArray(SUPER\_SIZE);  
3.  System.out.println("Array size:" + array.size()); // 4294967294  
4.  **for** (**int** i = 0; i < 100; i++) \{  
5.      array.set((**long**)Integer.MAX\_VALUE + i, (**byte**)3);  
6.      sum += array.get((**long**)Integer.MAX\_VALUE + i);  
7.  \}  
8.  System.out.println("Sum of 100 elements:" + sum);  // 300

**    但请注意这可能会导致JVM挂掉。**

**结束语**

sun.misc.Unsafe provides almost unlimited capabilities for exploring and modification of VM’s runtime data structures. Despite the fact that these capabilities are almost inapplicable in Java development itself, Unsafe is a great tool for anyone who want to study HotSpot VM without C++ code debugging or need to create ad hoc profiling instruments.

sun.misc.Unsafe提供了可以随意查看及修改JVM中运行时的数据结构，尽管这些功能在JAVA开发本身是不适用的，Unsafe是一个用于研究学习HotSpot虚拟机非常棒的工具，因为它不需要调用C++代码，或者需要创建即时分析的工具。

[Java]: http://lib.csdn.net/base/17
[view plain]: http://blog.csdn.net/fenglibing/article/details/17138079#
[CODE]: https://code.csdn.net/assets/CODE_ico.png
[CODE_CODE]: https://code.csdn.net/snippets/98141
[ico_fork.svg]: https://code.csdn.net/assets/ico_fork.svg
[ico_fork.svg 1]: https://code.csdn.net/snippets/98141/fork
[laugh.gif]: /images/20220720/3ab6c12b7ccf483ca0d3c154c9d9eea2.png