如何防止JAVA反射对单例类的攻击？

　　在我的上篇随笔中，我们知道了创建单例类有以下几种方式：

　　(1).饿汉式;

　　(2).懒汉式(、加同步锁的懒汉式、加双重校验锁的懒汉式、防止指令重排优化的懒汉式);

　　(3).登记式单例模式;

　　(4).静态内部类单例模式;

　　(5).枚举类型的单例模式。

在上面的5种实现方式中，除了枚举类型外，其他的实现方式是可以被JAVA的反射机制给攻击的，即使他的构造方法是私有化的，我们也可以做一下处理，从外部得到它的实例。

　　下面，我将会举例来说明：

说明：

　　Singleton.java     没有经过处理的饿汉式单例模式实现方式

　　Singleton6.java   枚举类型的单例模式

　　SingletonNotAttackByReflect.java         经过处理的饿汉式单例模式实现方式

　　SingletonReflectAttack.java    具体反射类

　　SingletonReflectAttackMain.java    JUnit测试类

举例1：不经过处理的单例类被JAVA反射机制攻击

Singleton.java    代码清单【1.1】

 public class Singleton
 {
     private static boolean flag = true;
     private static final Singleton INSTANCE = new Singleton();

     private Singleton()
     {
     }

     public static Singleton newInstance()
     {
         return INSTANCE;
     }

 }

SingletonReflectAttack.java  代码清单【1.2】

 /**
      * 单例模式被java反射攻击
      * @throws IllegalArgumentException
      * @throws InstantiationException
      * @throws IllegalAccessException
      * @throws InvocationTargetException
      * @throws SecurityException
      * @throws NoSuchMethodException
      */

     public static void attack() throws IllegalArgumentException, InstantiationException, IllegalAccessException, InvocationTargetException, SecurityException, NoSuchMethodException
     {
         Class<?> classType = Singleton.class;
         Constructor<?> constructor = classType.getDeclaredConstructor(null);
         constructor.setAccessible(true);
         Singleton singleton = (Singleton) constructor.newInstance();
         Singleton singleton2 = Singleton.newInstance();
         System.out.println(singleton == singleton2);  //false
     }

测试结果：SingletonReflectAttackMain.java  代码清单【1.3】

 /**
      * 1.测试单例模式被java反射攻击
      * @throws NoSuchMethodException
      * @throws InvocationTargetException
      * @throws IllegalAccessException
      * @throws InstantiationException
      * @throws SecurityException
      * @throws IllegalArgumentException
      */
     @Test
     public void testSingletonReflectAttack() throws IllegalArgumentException, SecurityException, InstantiationException, IllegalAccessException, InvocationTargetException, NoSuchMethodException
     {
         System.out.println("-------------单例模式被java反射攻击测试--------------");
         SingletonReflectAttack.attack();
         System.out.println("--------------------------------------------------");
     }
     

运行结果：

　　返回结果为false，说明创建了两个不同的实例。通过反射获取构造函数，然后调用setAccessible(true)就可以调用私有的构造函数；所以创建出来的两个实例时不同的对象。

如果要抵御这种攻击，就要修改构造器，让他在被要求创建第二个实例的时候抛出异常。

下面，我们对饿汉式单例模式做修改。

举例2.经过处理的单例类，JAVA反射机制攻击测试

SingletonNotAttackByReflect.java   代码清单【2.1】

 package com.lxf.singleton;

 import javax.management.RuntimeErrorException;

 public class SingletonNotAttackByReflect
 {
     private static boolean flag = false;
     private static final SingletonNotAttackByReflect INSTANCE = new SingletonNotAttackByReflect();

     //保证其不被java反射攻击
     private SingletonNotAttackByReflect()
     {
         synchronized (SingletonNotAttackByReflect.class)
         {
             if(false == flag)
             {
                 flag = !flag;
             }
             else
             {
                 throw new RuntimeException("单例模式正在被攻击");
             }

         }
     }

     public static SingletonNotAttackByReflect getInstance()
     {
         return INSTANCE;
     }

 }

SingletonReflectAttack.java  代码清单【2.2】

 public static void modifiedByAttack()
     {
         try
         {
             Class<SingletonNotAttackByReflect> classType = SingletonNotAttackByReflect.class;
             Constructor<SingletonNotAttackByReflect> constructor = classType.getDeclaredConstructor(null);
             constructor.setAccessible(true);
             SingletonNotAttackByReflect singleton = (SingletonNotAttackByReflect) constructor.newInstance();
             SingletonNotAttackByReflect singleton2 = SingletonNotAttackByReflect.getInstance();

             System.out.println(singleton == singleton2);
         }
         catch (Exception e)
         {
             e.printStackTrace();
         }

     }

SingletonReflectAttackMain.java  代码清单【2.3】

 /**
      * 2.修改后的单例模式被java反射攻击测试.
      * 攻击失败
      * @throws IllegalArgumentException
      * @throws SecurityException
      * @throws InstantiationException
      * @throws IllegalAccessException
      * @throws InvocationTargetException
      * @throws NoSuchMethodException
      */

     @Test
     public void testModifiedByattack() throws IllegalArgumentException, SecurityException, InstantiationException, IllegalAccessException, InvocationTargetException, NoSuchMethodException
     {
         System.out.println("-------------修改后的单例模式被java反射攻击测试--------------");
         SingletonReflectAttack.modifiedByAttack();
         System.out.println("----------------------------------------------------------");
     }

运行结果：

在之前，我们也介绍过，枚举类型的单例模式也可以防止被JAVA反射攻击，这里我们简单测试一下。

举例3：枚举类型的单例模式被JAVA反射机制攻击测试

Singleton6.java    代码清单【3.1】

 public enum Singleton6
 {
     INSTANCE;

     private Resource instance;

     Singleton6()
     {
         instance = new Resource();
     }

     public Resource getInstance()
     {
         return instance;
     }

 }

SingletonReflectAttack.java  代码清单【3.2】

     public static void enumAttack() throws SecurityException, NoSuchMethodException, IllegalArgumentException, InstantiationException, IllegalAccessException, InvocationTargetException
     {
         try
         {
             Class<Singleton6> classType = Singleton6.class;
             Constructor<Singleton6> constructor =(Constructor<Singleton6>) classType.getDeclaredConstructor();
             constructor.setAccessible(true);
             constructor.newInstance();

         }
         catch (Exception e)
         {
             e.printStackTrace();
         }

SingletonReflectAttackMain.java  代码清单【3.3】

 /**
      * 枚举类型的单例模式被java反射攻击测试
      * 攻击失败
      *
      * @throws IllegalArgumentException
      * @throws SecurityException
      * @throws InstantiationException
      * @throws IllegalAccessException
      * @throws InvocationTargetException
      * @throws NoSuchMethodException
      */

     @Test
     public void testenumAttack() throws IllegalArgumentException, SecurityException, InstantiationException, IllegalAccessException, InvocationTargetException, NoSuchMethodException
     {
         System.out.println("-------------枚举类型的单例模式被java反射攻击测试--------------");
         SingletonReflectAttack.enumAttack();
         System.out.println("----------------------------------------------------------");
     }

运行结果：

4.总结与拓展

所以，在项目开发中，我们要根据实际情况，选择最安全的单例模式实现方式。