[Java] 单例模式的反射漏洞和反序列化漏洞代码实例

package singleton;
 
import java.io.fileinputstream;
import java.io.fileoutputstream;
import java.io.objectinputstream;
import java.io.objectoutputstream;
import java.lang.reflect.constructor;
 
/**
 * 用反射和反序列化的方法破解单例模式
 * @author weiyx15
 *
 */
public class singletoncrack {
  public static void main(string[] args) throws exception
  {
    // 正常创建单例对象
    singletonlazy s1 = singletonlazy.getinstance();
    singletonlazy s2 = singletonlazy.getinstance();
    system.out.println(s1);
    system.out.println(s2);
    
    // 用反射破解单例
    class<singletonlazy> cls = (class<singletonlazy>) class.forname("singleton.singletonlazy");   // 获取singletonlazy类
    constructor<singletonlazy> cons = cls.getdeclaredconstructor(null);     // 获取singletonlazy的构造方法
    cons.setaccessible(true);       // 跳过方法的可见性检查
    singletonlazy s3 = cons.newinstance();  // 调用构造方法生成新对象
    singletonlazy s4 = cons.newinstance();  // 调用构造方法生成新对象
    system.out.println(s3);
    system.out.println(s4);
    
    // 用反序列化破解单例
    fileoutputstream fos = new fileoutputstream("object.out");  // 文件输出流
    objectoutputstream oos = new objectoutputstream(fos);     // 对象输出流
    oos.writeobject(s1);                    // 向文件序列化对象
    oos.close();                        // 关闭对象输出流
    fos.close();                        // 关闭文件输出流
    
    fileinputstream fis = new fileinputstream("object.out");  // 文件输入流
    objectinputstream ois = new objectinputstream(fis);     // 对象输入流
    singletonlazy s5 = (singletonlazy) ois.readobject();    // 从文件反序列化对象
    ois.close();                        // 关闭对象输入流
    fis.close();                        // 关闭文件输入流
    system.out.println(s5);
  }
}

singleton.singletonlazy@15db9742 // s1
singleton.singletonlazy@15db9742// s2
singleton.singletonlazy@6d06d69c// s3
singleton.singletonlazy@7852e922// s4
singleton.singletonlazy@3b07d329 // s5

package singleton;
 
import java.io.objectstreamexception;
import java.io.serializable;
 
/**
 * 排除了反射漏洞和反序列化漏洞的懒汉式单例模式
 * @author weiyx15
 *
 */
public class singletonlazysafe implements serializable{
  private static singletonlazysafe instance;
  
  private singletonlazysafe() {
    // 防止反射漏洞通过再次调用私有构造方法实例化新的instance
    if (instance != null)
    {
      throw new runtimeexception();   // 抛出运行时异常
    }
  }
  
  public static synchronized singletonlazysafe getinstance() {
    if (instance == null)   // 如果未实例化，则先实例化
    {
      instance = new singletonlazysafe(); // 调用getinstance方法后再实例化对象
    }
    return instance;
  }
  
  /**
   * 从i/o流读取对象时会调用readresolve接口
   * 在readresolve接口中直接返回instance对象
   * 避免反序列化时重新实例化对象
   * @return 单例对象
   * @throws objectstreamexception
   */
  private object readresolve() throws objectstreamexception {
    return instance;
  }
}