单例模式中解决反射和反序列化漏洞_反射代理存在反序列化漏洞-优快云博客

 转载自：http://blog.youkuaiyun.com/hardwin/article/details/51477359

一、懒汉式单例模式，解决反射和反序列化漏洞

[java]view plaincopy 
     
 package com.iter.devbox.singleton;  
   
 import java.io.ObjectStreamException;  
 import java.io.Serializable;  
   
 /** 
  * 懒汉式（如何防止反射和反序列化漏洞） 
  * @author Shearer 
  * 
  */  
 public class SingletonDemo6 implements Serializable{  
       
     // 类初始化时，不初始化这个对象（延迟加载，真正用的时候再创建）  
     private static SingletonDemo6 instance;  
       
     private SingletonDemo6() {  
         // 防止反射获取多个对象的漏洞  
         if (null != instance) {  
             throw new RuntimeException();  
         }  
     }  
       
     // 方法同步，调用效率低  
     public static synchronized SingletonDemo6 getInstance() {  
         if (null == instance)  
             instance = new SingletonDemo6();  
         return instance;  
     }  
   
     // 防止反序列化获取多个对象的漏洞。  
     // 无论是实现Serializable接口，或是Externalizable接口，当从I/O流中读取对象时，readResolve()方法都会被调用到。  
     // 实际上就是用readResolve()中返回的对象直接替换在反序列化过程中创建的对象。  
     private Object readResolve() throws ObjectStreamException {    
         return instance;  
     }  
 }  
   
   
 package com.iter.devbox.singleton;  
   
 import java.io.FileInputStream;  
 import java.io.FileOutputStream;  
 import java.io.ObjectInputStream;  
 import java.io.ObjectOutputStream;  
   
 public class Client2 {  
   
     public static void main(String[] args) throws Exception {  
         SingletonDemo6 sc1 = SingletonDemo6.getInstance();  
         SingletonDemo6 sc2 = SingletonDemo6.getInstance();  
         System.out.println(sc1); // sc1，sc2是同一个对象  
         System.out.println(sc2);  
           
         // 通过反射的方式直接调用私有构造器（通过在构造器里抛出异常可以解决此漏洞）  
 /*      Class<SingletonDemo6> clazz = (Class<SingletonDemo6>) Class.forName("com.iter.devbox.singleton.SingletonDemo6"); 
         Constructor<SingletonDemo6> c = clazz.getDeclaredConstructor(null); 
         c.setAccessible(true); // 跳过权限检查 
         SingletonDemo6 sc3 = c.newInstance(); 
         SingletonDemo6 sc4 = c.newInstance(); 
         System.out.println(sc3);  // sc3，sc4不是同一个对象 
         System.out.println(sc4);*/  
           
         // 通过反序列化的方式构造多个对象（类需要实现Serializable接口）  
           
         // 1. 把对象sc1写入硬盘文件  
         FileOutputStream fos = new FileOutputStream("object.out");  
         ObjectOutputStream oos = new ObjectOutputStream(fos);  
         oos.writeObject(sc1);  
         oos.close();  
         fos.close();  
           
         // 2. 把硬盘文件上的对象读出来  
         ObjectInputStream ois = new ObjectInputStream(new FileInputStream("object.out"));  
         // 如果对象定义了readResolve()方法，readObject()会调用readResolve()方法。从而解决反序列化的漏洞  
         SingletonDemo6 sc5 = (SingletonDemo6) ois.readObject();  
         // 反序列化出来的对象，和原对象，不是同一个对象。如果对象定义了readResolve()方法，可以解决此问题。  
         System.out.println(sc5);   
         ois.close();  
     }  
   
 }  
 
     
   

二、静态内部类式单例模式（解决反射和反序列化漏洞）

[java]view plaincopy 
     
 package com.iter.devbox.singleton;  
   
 import java.io.ObjectStreamException;  
 import java.io.Serializable;  
   
 /** 
  * 静态内部类实现方式（也是一种懒加载方式） 
  * 这种方式：线程安全，调用效率高，并且实现了延迟加载 
  * 解决反射和反序列化漏洞 
  * @author Shearer 
  * 
  */  
 public class SingletonDemo7 implements Serializable{  
       
     private static class SingletonClassInstance {  
         private static final SingletonDemo7 instance = new SingletonDemo7();  
     }  
       
     // 方法没有同步，调用效率高  
     public static SingletonDemo7 getInstance() {  
         return SingletonClassInstance.instance;  
     }  
       
     // 防止反射获取多个对象的漏洞  
     private SingletonDemo7() {  
         if (null != SingletonClassInstance.instance)  
             throw new RuntimeException();  
     }  
       
     // 防止反序列化获取多个对象的漏洞  
     private Object readResolve() throws ObjectStreamException {    
         return SingletonClassInstance.instance;  
     }  
 }  
   
   
 package com.iter.devbox.singleton;  
   
 import java.io.FileInputStream;  
 import java.io.FileOutputStream;  
 import java.io.ObjectInputStream;  
 import java.io.ObjectOutputStream;  
 import java.lang.reflect.Constructor;  
   
 public class Client3 {  
   
     public static void main(String[] args) throws Exception {  
         SingletonDemo7 sc1 = SingletonDemo7.getInstance();  
         SingletonDemo7 sc2 = SingletonDemo7.getInstance();  
         System.out.println(sc1); // sc1，sc2是同一个对象  
         System.out.println(sc2);  
           
         // 通过反射的方式直接调用私有构造器（通过在构造器里抛出异常可以解决此漏洞）  
         Class<SingletonDemo7> clazz = (Class<SingletonDemo7>) Class.forName("com.iter.devbox.singleton.SingletonDemo7");  
         Constructor<SingletonDemo7> c = clazz.getDeclaredConstructor(null);  
         c.setAccessible(true); // 跳过权限检查  
         SingletonDemo7 sc3 = c.newInstance();  
         SingletonDemo7 sc4 = c.newInstance();  
         System.out.println("通过反射的方式获取的对象sc3：" + sc3);  // sc3，sc4不是同一个对象  
         System.out.println("通过反射的方式获取的对象sc4：" + sc4);  
           
         // 通过反序列化的方式构造多个对象（类需要实现Serializable接口）  
           
         // 1. 把对象sc1写入硬盘文件  
         FileOutputStream fos = new FileOutputStream("object.out");  
         ObjectOutputStream oos = new ObjectOutputStream(fos);  
         oos.writeObject(sc1);  
         oos.close();  
         fos.close();  
           
         // 2. 把硬盘文件上的对象读出来  
         ObjectInputStream ois = new ObjectInputStream(new FileInputStream("object.out"));  
         // 如果对象定义了readResolve()方法，readObject()会调用readResolve()方法。从而解决反序列化的漏洞  
         SingletonDemo7 sc5 = (SingletonDemo7) ois.readObject();  
         // 反序列化出来的对象，和原对象，不是同一个对象。如果对象定义了readResolve()方法，可以解决此问题。  
         System.out.println("对象定义了readResolve()方法，通过反序列化得到的对象：" + sc5);   
         ois.close();  
     }  
   
 }  