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

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);

     }

}

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;

     }

}