序列化——保护性地编写readObject方法

布满荆棘的人生 2024-03-29 15:25 16阅读 0赞

### 看一个序列化破坏 final 的例子 ###

import cn.hutool.core.date.DateUtil;
    import java.io.Serializable;
    import java.util.Date;
     
    public final class Period implements Serializable {
        private static final long serialVersionUID = 1L;
     
        private final Date start;
        private final Date finish;
     
        public Date getStart() {
            return start;
        }
     
        public Date getFinish() {
            return finish;
        }
     
        public Period(Date start, Date finish) {
            if (start == null) {
                throw new NullPointerException("start 不能为null");
            }
            if (finish == null) {
                throw new NullPointerException("finish 不能为null");
            }
            this.start =  new Date(start.getTime());
            this.finish = new Date(finish.getTime());
            if (start.after(finish)) {
                throw new IllegalArgumentException("start 不能在 finish 之后");
            }
        }
     
        @Override
        public String toString() {
            return DateUtil.format(start,"yyyy-MM-dd HH:mm:ss") + "~" + DateUtil.format(finish,"yyyy-MM-dd HH:mm:ss");
        }
     
    }

import cn.hutool.core.date.DateUtil;
    import java.io.*;
    import java.util.Date;
     
    public class Client {
        public static void main(String[] args) throws Exception {
            /**
             *  修改字节行数     177-180    110、47、73、36
             *  日期 d1         2020-11-03 11:22:33 变成 2019-11-03 11:22:33
             *
             *  修改字节行数     160-163   -124、59、-79、111
             *  日期 d2         2021-11-03 12:13:15 变成 2022-11-03 12:13:15
             */
            Date d1 = DateUtil.parse("2020-11-03 11:22:33");
            Date d2 = DateUtil.parse("2021-11-03 12:13:15");
     
            Period p = new Period(d1, d2);
            ser(p);
     
            byte[] bytes = readBytes(new File("C:\\Users\\admin\\Desktop\\file_upload\\car.ser"));
            for (byte b : bytes) {
                System.out.println(b);
            }
            bytes[160] = 110;
            bytes[161] = 47;
            bytes[162] = 73;
            bytes[163] = 36;
     
            p = deSer(bytes);
            System.out.println(p);
        }
     
         static byte[] readBytes(File file) throws IOException {
            FileInputStream in = null;
            try {
                in =new FileInputStream(file);
                //当文件没有结束时，每次读取一个字节显示
                byte[] data=new byte[in.available()];
                in.read(data);
                in.close();
                return data;
            } catch (IOException e) {
                e.printStackTrace();
            }finally {
                in.close(); //关闭流
            }
            return null;
        }
     
        static void ser(Period p) throws IOException {
            FileOutputStream fos = new FileOutputStream("C:\\Users\\admin\\Desktop\\file_upload\\car.ser");
            ObjectOutputStream os = new ObjectOutputStream(fos);
            os.writeObject(p);
            os.close();
        }
     
        static Period deSer(byte[] bytes) throws IOException, ClassNotFoundException {
            ObjectInputStream in = new ObjectInputStream(new ByteArrayInputStream(bytes));
            Period p = (Period) in.readObject();
            in.close();
            return p;
        }
    }

Period是final 类，但现在发现这个类被破坏了。

破坏的过程 序列化- 文件 - （破坏者）读取文件字节流- 修改字节流 - 执行反序列化。

所以，在序列化中保护是没有用的，必须在反序列化的时候做校验，我们在Period类加上readObject方法

private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
            in.defaultReadObject();
            if(start.after(finish)){
                throw new InvalidObjectException("deSer 错误，起始时间错误");
            }
        }

以上就搞定了？当然不是，还有其他的攻击手段

import cn.hutool.core.date.DateUtil;
    import java.io.*;
    import java.util.Date;
    
    public final class MutablePeriod implements Serializable {
        private static final long serialVersionUID = 1L;
        private final Period period;
        private final Date start;
        private final Date finish;
    
        public MutablePeriod() throws IOException, ClassNotFoundException {
            Date d1 = DateUtil.parse("2020-11-03 11:22:33"); // 139 - 143
            Date d2 = DateUtil.parse("2021-01-03 12:13:15"); // 124 - 126
            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            ObjectOutputStream oos = new ObjectOutputStream(bos);
            oos.writeObject(new Period(d1, d2));
            byte[] ref = {0x71,0,0x7e,0,5}; // Ref #5
            bos.write(ref);//start
            ref[4] =4; // Ref#4
            bos.write(ref); // finish
    
    
            ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(bos.toByteArray()));
            period = (Period) ois.readObject();
            start = (Date) ois.readObject();
            finish = (Date) ois.readObject();
        }
    
        public static void main(String[] args) throws IOException, ClassNotFoundException {
            MutablePeriod mp = new MutablePeriod();
            Period p = mp.period;
            Date pe = mp.finish;
            System.out.println(DateUtil.format(p.getFinish(),"yyyy-MM-dd HH:mm:ss"));
            pe.setYear(76);
            System.out.println(DateUtil.format(p.getFinish(),"yyyy-MM-dd HH:mm:ss"));
        }
    }

> 2021-01-03 12:13:15  
> 1976-01-03 12:13:15

我们可以看到，在反序列化后得到对象，我们修改了对象的fina数据 ，这显然具有安全隐患

#### 如何进一步改进 readObject？ ####

读取对象的时候，重新创建对象的start和finish对象，避免对象被外部引用污染

注：必须去掉final修饰符

private  Date start;
    private  Date finish;
    
    private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
            in.defaultReadObject();
            start = new Date(start.getTime());
            finish = new Date(finish.getTime());
            if(start.after(finish)){
                throw new InvalidObjectException("deSer 错误，序列化对象已被破坏，起止时间错误");
            }
    }

其实更好的办法是 ，能用基本类型的用基本类型。基本类型与引用类型不同，无法被其他引用的修改所“污染”。我们改造一下

import cn.hutool.core.date.DateUtil;
    import java.io.*;
    import java.util.Date;
    
    public class Period2 implements Serializable {
        private static final long serialVersionUID = 1L;
     
        private final long start;
        private final long finish;
     
        public Period2(Date start, Date finish) {
            if (start == null) {
                throw new NullPointerException("start 不能为null");
            }
            if (finish == null) {
                throw new NullPointerException("finish 不能为null");
            }
     
            this.start = start.getTime();
            this.finish = finish.getTime();
     
            if (start.after(finish)) {
                throw new IllegalArgumentException("start 不能在 finish 之前");
            }
            
        }
     
        public Date getStart() {
            return new Date(start);
        }
     
        public Date getFinish() {
            return new Date(finish);
        }
     
        @Override
        public String toString() {
            return DateUtil.format(new Date(start),"yyyy-MM-dd HH:mm:ss") + "~" + DateUtil.format(new Date(finish),"yyyy-MM-dd HH:mm:ss");
        }
     
     
        private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
            in.defaultReadObject();
            if(start>finish ){
                throw new InvalidObjectException("deSer 错误，序列化对象已被破坏，起始时间错误");
            }
        }
    }

对于如何编写保护性的 readObject，有以下建议

1.  对于对象引用域必须保持为私有的类，要保护性地拷贝这些域中的每个对象。不可变类的可变组件就属于这一类别
2.  对于任何约束条件，如果检查失败，则抛出 InvalidObjectException 异常。这些检查动作应该跟在所有的保护性拷贝之后。
3.  如果整个对象图在被反序列化之后必须进行校验，就应该使用 ObjectInputValidation 接口