如何防止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.總結與拓展

 所以，在項目開發中，我們要根據實際情況，選擇最安全的單例模式實現方式。