单例模式安全之反射攻击

源码

单例模式这里就不谈了，什么是单例模式可参考七种Java单例模式详解,这里是关于单例模式安全方面的，当然了这里说的安全不是线程安全。

什么是反射攻击呢

1. 在Java中，由于反射的功能实在是太强了，通过动态访问类并设置AccessAllow 使得可以访问对象的私有属性方法等。
2. 在单例模式中，我们使用private 修饰构造方法对外隐藏，防止外部new 对象，但是在反射的存在下，private的存在形同虚设，通过反射设置AcceessAllow 即可访问构造方法，这时的单例就不是单例了。

反射攻击重现

这里使用volatile 双重检验锁实现线程安全的单例

package com.fine.reflect;

/**
 * 单例
 * volatile 双重校验
 *
 * @author finefine at: 2019-05-02 22:22
 */
public class Singleton {
    private volatile static Singleton INSTANCE;

    private Singleton() {

    }

    public static Singleton getInstance() {

        if (INSTANCE==null){

            //同步代码块
            synchronized (Singleton.class){
                if (INSTANCE == null) {
                    INSTANCE = new Singleton();
                }
            }

        }
        return INSTANCE;
    }

}

反射攻击实现

package com.fine.reflect;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

/**
 * @author finefine at: 2019-05-02 22:26
 */
public class ReflectAttackTest {

    public static void main(String[] args) {

        Singleton singleton = Singleton.getInstance();

        Class clazz = singleton.getClass();
        try {
            Constructor<Singleton> constructor = clazz.getDeclaredConstructors()[0];

            //设置允许访问私有的构造器
            constructor.setAccessible(true);
            Singleton singleton1 = constructor.newInstance();

            if (singleton1 != null&&singleton1.getClass().equals(singleton.getClass())) {
                System.out.println("通过反射构造除了对象");
                return;
            }

            if (singleton == singleton1) {
                System.out.println("是同一个对象");
            } else {
                System.out.println("是两个不同的对象");
            }
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }

    }
}

运行结果

debug 分析

可以看到singleton 和 singleton1 都是Singleton 的对象，一个hashcode是466 一个是469。constructor=private com.fine.reflect.Singleton() 说明了的确是Singleton的私有构造方法。

通过反射，我们创造出了不止一个对象，因此该单例模式配破坏了，是不安全的，这就是反射攻击。

预防反射攻击

要避免通过反射来调用私有构造器这是行不通的，那么该如何做呢，这里有两种做法。

• 当尝试使用构造方法new 对象时，直接抛出异常
• 使用枚举，枚举类jvm底层保证了不可new。

第一种

单例写法：

package com.fine.reflect.enhance;

/**
 * 单例
 * volatile 双重校验
 *
 * @author finefine at: 2019-05-02 22:22
 */
public class Singleton {
    private volatile static Singleton INSTANCE;

    private Singleton() {
        //如果已存在，直接抛出异常，保证只会被new 一次
        if (INSTANCE != null) {
            throw new RuntimeException("对象已存在不可重复创建");
        }
    }

    public static Singleton getInstance() {

        if (INSTANCE==null){

            //同步代码块
            synchronized (Singleton.class){
                if (INSTANCE == null) {
                    INSTANCE = new Singleton();
                }
            }

        }
        return INSTANCE;
    }

}

测试代码：

package com.fine.reflect;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

import com.fine.reflect.enhance.Singleton;

/**
 * @author finefine at: 2019-05-02 22:26
 */
public class ReflectAttackTest {

    public static void main(String[] args) {

        Singleton singleton = Singleton.getInstance();


        Class clazz = singleton.getClass();
        try {
            Constructor<Singleton> constructor = clazz.getDeclaredConstructors()[0];

            //设置允许访问私有的构造器
            constructor.setAccessible(true);
            Singleton singleton1 = constructor.newInstance();

            if (singleton1 != null && singleton1.getClass().equals(singleton.getClass())) {
                System.out.println("通过反射构造除了对象");
            } else {
                return;
            }

            if (singleton == singleton1) {
                System.out.println("是同一个对象");
            } else {
                System.out.println("是两个不同的对象");
            }
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }

    }
}

运行结果：

直接抛出了异常。

第二种

单例代码：

package com.fine.reflect.enhance;

/**
 * 单例
 * 枚举
 *
 * @author finefine at: 2019-05-02 22:22
 */
public enum  SingletonEnum {
    INSTANCE;
}

测试代码：

package com.fine.reflect.enhance;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

/**
 * @author finefine at: 2019-05-03 00:50
 */
public class SingletonEnumTest {

    public static void main(String[] args) {
        SingletonEnum singletonEnum = SingletonEnum.INSTANCE;

        Class clazz = singletonEnum.getClass();
        try {
            Constructor<Singleton> constructor = clazz.getDeclaredConstructors()[0];

            //设置允许访问私有的构造器
            constructor.setAccessible(true);
            Singleton singleton1 = constructor.newInstance();

            if (singleton1 != null && singleton1.getClass().equals(singletonEnum.getClass())) {
                System.out.println("通过反射构造除了对象");
            } else {
                return;
            }

        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }

    }
}

运行结果：

抛出了java.lang.IllegalArgumentException: Cannot reflectively create enum objects at java.lang.reflect.Constructor.newInstance(Constructor.java:417)
​