sun.misc.unsafe类的使用

这个帖子是关于JAVA中鲜为人知的特性的后续更新,如果想得到下次在线讨论的更新,请通过邮件订阅,并且不要忘了在评论区留下你的意见和建议。

Java是一个安全的开发工具,它阻止开发人员犯很多低级的错误,而大部份的错误都是基于内存管理方面的。如果你想搞破坏,可以使用Unsafe这个类。这个类是属于sun.* API中的类,并且它不是J2SE中真正的一部份,因此你可能找不到任何的官方文档,更可悲的是,它也没有比较好的代码文档。

实例化sun.misc.Unsafe

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

1)、Unsafe类的构造函数是私有的;

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

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

[java] view
plain
copy

  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安全检查以及其它的一些底层的东西。即使构造函数是私有,我们也可以通过这个方法创建它的实例。

(这个对单例模式情有独钟的程序员来说将会是一个噩梦,它们没有办法阻止这种方式调用

看下面一个实例(注:为了配合这个主题,译者将原实例中的public构造函数修改为了私有的):

[java] view
plain
copy

  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. // This creates an instance of player class without any initialization
  7. Player p = (Player) unsafe.allocateInstance(Player.class);
  8. System.out.println(p.getAge()); // Print 0
  9. p.setAge(45); // Let‘s now set age 45 to un-initialized object
  10. System.out.println(p.getAge()); // Print 45
  11. }
  12. }
  13. class Player {
  14. private int age = 12;
  15. private Player() {
  16. this.age = 50;
  17. }
  18. public int getAge() {
  19. return this.age;
  20. }
  21. public void setAge(int age) {
  22. this.age = age;
  23. }
  24. }

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

  1. String password = new String("[email protected]$e");
  2. String fake = new String(password.replaceAll(".", "?"));
  3. System.out.println(password); // [email protected]$e
  4. System.out.println(fake); // ????????????
  5. getUnsafe().copyMemory(fake, 0L, null, toAddress(password), sizeOf(password));
  6. System.out.println(password); // ????????????
  7. System.out.println(fake); // ????????????

运行时动态创建类

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

[java] view
plain
copy

  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. //Method to read .class file
  6. private static byte[] getClassContent() throws Exception {
  7. File f = new File("/home/mishadoff/tmp/A.class");
  8. FileInputStream input = new FileInputStream(f);
  9. byte[] content = new byte[(int)f.length()];
  10. input.read(content);
  11. input.close();
  12. return content;
  13. }

4)、超大数组

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

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

[java] view
plain
copy

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

应用示例

[java] view
plain
copy

  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++代码,或者需要创建即时分析的工具。

参考

http://mishadoff.github.io/blog/java-magic-part-4-sun-dot-misc-dot-unsafe/

sun.misc.unsafe类的使用

时间: 2024-10-09 09:09:19

sun.misc.unsafe类的使用的相关文章

Java sun.misc.unsafe类的使用

Java是一个安全的开发工具,它阻止开发人员犯很多低级的错误,而大部份的错误都是基于内存管理方面的.如果你想搞破坏,可以使用Unsafe这个类.这个类是属于sun.*API中的类,并且它不是J2SE中真正的一部份,因此你可能找不到任何的官方文档,更可悲的是,它也没有比较好的代码文档. 1.实例化sun.misc.Unsafe 如果你尝试创建Unsafe类的实例,基于以下两种原因是不被允许的. 1).Unsafe类的构造函数是私有的: 2).虽然它有静态的getUnsafe()方法,但是如果你尝试

java的sun.misc.Unsafe类

阅读目录 前言 Unsafe类的作用 获取Unsafe对象 Unsafe类中的API 前言 以下sun.misc.Unsafe源码和demo基于jdk1.7: 最近在看J.U.C里的源码,很多都用到了sun.misc.Unsafe这个类,一知半解,看起来总感觉有点不尽兴,所以打算对Unsafe的源码及使用做个分析: 另外,网上找了份c++的源代码natUnsafe.cc(可惜比较老,Copyright (C) 2006, 2007年的,没找到新的),也就是sun.misc.Unsafe的C++实

Java Magic. Part 4: sun.misc.Unsafe

原文地址 译文地址 译者:许巧辉 校对:梁海舰 Java是一门安全的编程语言,防止程序员犯很多愚蠢的错误,它们大部分是基于内存管理的.但是,有一种方式可以有意的执行一些不安全.容易犯错的操作,那就是使用Unsafe类. 本文是sun.misc.Unsafe公共API的简要概述,及其一些有趣的用法. Unsafe 实例 在使用Unsafe之前,我们需要创建Unsafe对象的实例.这并不像Unsafe unsafe = new Unsafe()这么简单,因为Unsafe的构造器是私有的.它也有一个静

聊聊序列化(二)使用sun.misc.Unsafe绕过new机制来创建Java对象

在序列化的问题域里面有一个常见的问题,就是反序列化时用何种方式来创建Java对象,因为反序列化的目的是把一段二进制流转化成一个对象. 在Java里面创建对象有几种方式: 1. 显式地调用new语句, 比如 DemoClass demo = new DemoClass() 2. 利用反射机制,通过Class对象的newInstance()方法,比如DemoClass demo = DemoClass.class.newInstance(). 但是有个前提就是必须提供无参的构造函数 3. 利用反射机

java对象的内存布局(二):利用sun.misc.Unsafe获取类字段的偏移地址和读取字段的值

在上一篇文章中.我们列出了计算java对象大小的几个结论以及jol工具的使用,jol工具的源代码有兴趣的能够去看下.如今我们利用JDK中的sun.misc.Unsafe来计算下字段的偏移地址,一则验证下之前文章中的结论,再则跟jol输出结果对照下.怎样获取sun.misc.Unsafe对象.能够參考这篇文章. public class VO { public int a = 0; public long b = 0; public static String c= "123"; pub

利用sun.misc.Unsafe获取类字段的偏移地址和读取字段的值

我们列出了计算java对象大小的几个结论以及jol工具的使用,jol工具的源码有兴趣的可以去看下.现在我们利用JDK中的sun.misc.Unsafe来计算下字段的偏移地址,一则验证下之前文章中的结论,再则跟jol输出结果对比下.如何获取sun.misc.Unsafe对象,可以参考这篇文章. [java] view plain copy public class VO { public int a = 0; public long b = 0; public static String c= "

认识 sun.misc.Unsafe

笼罩在迷雾之中的 Unsafe 私有API,有人认为应该废弃,也有人认为应该开放. [2015年07月28日] Oracle 宣称要在 Java 9 中去除私有 API: sun.misc.Unsafe, 这就像点燃了炸药桶, 遭到 许多开发者的抗议, 他们认为 这会严重破坏Java的生态系统 开源博主 Rafael Winterhalter 在博文 "Understanding sun.misc.Unsafe" 中说, 底层编程(low-level programming) 中经常会

Java中的sun.misc.Unsafe包

chronicle项目:https://github.com/peter-lawrey/Java-Chronicle 这个项目是利用mmap机制来实现高效的读写数据,号称每秒写入5到20百万条数据. 作者有个测试,写入1百万条log用时0.234秒,用java自带的logger,用时7.347秒. 在看chronicle的源代码,发现一个牛B的利用Unsafe来直接读写内存,从而提高效率的例子. 详细见这个类:https://github.com/peter-lawrey/Java-Chroni

sun.misc.unsafe

Java中大部分错误都是基于内存管理方面的.如果想破坏,可以使用Unsafe这个类. 实例化Unsafe: 下面两种方式是不行的 private Unsafe() {} //私有构造方法 @CallerSensitive public static Unsafe getUnsafe() { Class var0 = Reflection.getCallerClass(); if(!VM.isSystemDomainLoader(var0.getClassLoader())) {//如果不是JDK