书中本条目开头给了一个代码例子。
public final class Period implements Serializable {
private final Date start;
private final Date end;
public Period(Date start, Date end) {
this.start = new Date(start.getTime());
this.end = new Date(end.getTime());
if (this.start.compareTo(this.end) > 0)
throw new IllegalArgumentException(
start + " after " + end);
}
public Date start () { return new Date(start.getTime()); }
public Date end () { return new Date(end.getTime()); }
public String toString() { return start + " - " + end; }
}
public class BogusPeriod {
private static final byte[] serializedForm = new byte[] {
(byte)0xac, (byte)0xed, 0x00, 0x05, 0x73, 0x72, 0x00, 0x06,
0x50, 0x65, 0x72, 0x69, 0x6f, 0x64, 0x40, 0x7e, (byte)0xf8,
0x2b, 0x4f, 0x46, (byte)0xc0, (byte)0xf4, 0x02, 0x00, 0x02,
0x4c, 0x00, 0x03, 0x65, 0x6e, 0x64, 0x74, 0x00, 0x10, 0x4c,
0x6a, 0x61, 0x76, 0x61, 0x2f, 0x75, 0x74, 0x69, 0x6c, 0x2f,
0x44, 0x61, 0x74, 0x65, 0x3b, 0x4c, 0x00, 0x05, 0x73, 0x74,
0x61, 0x72, 0x74, 0x71, 0x00, 0x7e, 0x00, 0x01, 0x78, 0x70,
0x73, 0x72, 0x00, 0x0e, 0x6a, 0x61, 0x76, 0x61, 0x2e, 0x75,
0x74, 0x69, 0x6c, 0x2e, 0x44, 0x61, 0x74, 0x65, 0x68, 0x6a,
(byte)0x81, 0x01, 0x4b, 0x59, 0x74, 0x19, 0x03, 0x00, 0x00,
0x78, 0x70, 0x77, 0x08, 0x00, 0x00, 0x00, 0x66, (byte)0xdf,
0x6e, 0x1e, 0x00, 0x78, 0x73, 0x71, 0x00, 0x7e, 0x00, 0x03,
0x77, 0x08, 0x00, 0x00, 0x00, (byte)0xd5, 0x17, 0x69, 0x22,
0x00, 0x78 };
public static void main(String[] args) {
Period p = (Period) deserialize(serializedForm);
System.out.println(p);
}
private static Object deserialize(byte[] sf) {
try {
InputStream is = new ByteArrayInputStream(sf);
ObjectInputStream ois = new ObjectInputStream(is);
return ois.readObject();
} catch (Exception e) {
throw new IllegalArgumentException(e);
}
}
}
什么意思呢？ 我们从上一条中知道，对象的序列化与反序列化的流程，序列化时把对象通过 ObjectOutputStream 的 writeObject 方法，转换为二进制写入文件或磁盘，对应的反序列化则是通过 ObjectInputStream 的 readObject 方法，把文件中的二进制转换为对象，那么，ObjectInputStream 是流，需要传入二进制的内容，按照通常理解，需要路径获取文件，然后转换为流，ObjectInputStream 的构造方法接收流，我们可以把文件转换为流，当然也可以把字节数组转换为流。上一条中用的是 FileInputStream 找到文本，包装为流，本条中上面的例子，则是用 ByteArrayInputStream 把字节数组包装为流，内容有了，就可以反序列化了。
我们假设上面的字节数组的数据就是 Period 对象的序列化后对应的内容，那么就可以通过字符的形式来反序列化，这就证明了可以从文本中读取数据进行反序列化，也可以通过按照规则生成的字节数组中进行反序列化，此时，按照数中所说，运行代码后，打印的结果为 "Fri Jan 01 12:00:00 PST 1999 - Sun Jan 01 12:00:00 PST 1984"。 很明显，我们的 Period 对象的构造方法中有时间的约束，但明显此时违反了约束，仍能生成对象。这就说明了反序列化实际上还对应着一个隐形的构造方法，可以不受约束。如果有心人篡改信息来攻击我们的代码，怎么办？
我们知道，反序列化时要执行 readObject 方法，同时我们自定义序列化时也提到了对象中编写 readObject 方法，结决方法出现了
private void readObject(ObjectInputStream s)
throws IOException, ClassNotFoundException {
s.defaultReadObject();
if (start.compareTo(end) > 0)
throw new InvalidObjectException(start +" after "+ end);
}
反序列化会执行这个方法，所以，在执行 s.defaultReadObject(); 后获取对象的属性值，然后做校验，不符合情况时就抛出异常，就解决上面的问题了。
上面的例子是通过整体改变数据源来攻击，但还隐藏着一个小问题，如果是内部通过关联对象来修改属性，上面的方法就防不住了。
public class MutablePeriod {
public final Period period;
public final Date start;
public final Date end;
public MutablePeriod() {
try {
ByteArrayOutputStream bos = new ByteArrayOutputStream();
ObjectOutputStream out = new ObjectOutputStream(bos);
out.writeObject(new Period(new Date(), new Date()));
byte[] ref = { 0x71, 0, 0x7e, 0, 5 }; // Ref #5
bos.write(ref); // The start field
ref[4] = 4; // Ref # 4
bos.write(ref); // The end field
ObjectInputStream in = new ObjectInputStream(
new ByteArrayInputStream(bos.toByteArray()));
period = (Period) in.readObject();
start = (Date) in.readObject();
end = (Date) in.readObject();
} catch (Exception e) {
throw new AssertionError(e);
}
}
}
private static void test() {
MutablePeriod mp = new MutablePeriod();
Period p = mp.period;
Date pEnd = mp.end;
// Let's turn back the clock
pEnd.setYear(78);
System.out.println(p);
// Bring back the 60s!
pEnd.setYear(69);
System.out.println(p);
}
这段代码的意思是 MutablePeriod 对象中 包含了三个属性，Period 和 Date ，本来毫不相关的三个属性，但是，在序列化时，存入 Period 中的两个属性的时间是当前时间，然后我们通过序列化数据时，人为的添加字节数组，加入一段数据，
byte[] ref = { 0x71, 0, 0x7e, 0, 5 }; // Ref #5
bos.write(ref); // The start field
ref[4] = 4; // Ref # 4
bos.write(ref); // The end field
使 MutablePeriod 对象中的 Date start; Date end; 与 Period 对象中的 Date start; Date end; 建立起关系，使MutablePeriod中的两个Date引用指向Period中的Date域，这就是“恶意编制的对象引用”，这样，只要改变了 MutablePeriod 中 Date 的值，也就是改变了 Period 中 Date 的值。所以上述代码打印出来的值为
Tue Dec 25 11:28:27 CST 2018 - Mon Dec 25 11:28:27 CST 1978
Tue Dec 25 11:28:27 CST 2018 - Thu Dec 25 11:28:27 CST 1969
这个明显的，也违反了 Period 的构造条件，end 的时间居然比 start 的时间早。
对于上述问题，怎么解决呢？既然外面通过恶意的对象引用，我们没办法去把它们的引用去掉，那么只能在自己的代码中加防护了，反序列化时，会用到 readObject 方法，我们在这个里面，通过保护性clone方法来结决，如下
private void readObject(ObjectInputStream s) throws IOException,
ClassNotFoundException {
s.defaultReadObject();
start = new Date(start.getTime());
end = new Date(end.getTime());
if (start.compareTo(end) > 0)
throw new InvalidObjectException(start + " after " + end);
}
我们重新获取 start 和 end 的时间，然后再次创建一个对象，保护性的clone，这样，引用就被切断了，不会被外部攻击了。但这样修改后，就需要把成员变量的 start 和 end 的final 修饰的关键字去掉了。这样，再次运行，结果明显是当前时间，不受外部影响。
Tue Dec 25 11:54:55 CST 2018 - Tue Dec 25 11:54:55 CST 2018
Tue Dec 25 11:54:55 CST 2018 - Tue Dec 25 11:54:55 CST 2018