シリアライゼーションの使用は深刻な問題ですか？

Question

私は、特定のメッセージに関するすべての情報を含むチャットプログラム用のクラスメッセージを作成しました。メッセージのインスタンスは、サーバーとクライアントの間で前後に送信されます。私はこれらのメッセージを交換するためにシリアル化（ObjectInputStream/ObjectOutputStream）を使用しています。

私は、シリアライズとデシリアライズのプロセスを制御できません。私にとって最大の問題は、何人かの攻撃者が本当に重いメッセージ（数ギガバイトなど）を送信したい場合、それを避ける方法がなく、深刻な記憶上の問題が生じる可能性があるということです。これはサービス拒否のために使用され、深刻なものです。

シリアライゼーションとそのセキュリティに関するさまざまな話題を取り上げましたが、この些細な問題を回避する方法については誰も言及していません。バッファを使用してデータをバイト配列として取得して、いつでも読み取りを停止できるようにしたいと考えています。しかし、私はシリアル化でこれを行う方法を見つけることができませんでした。 質問：どうすればいいですか？

シリアル化のセキュリティ上の問題についてのコメントも歓迎します。シリアライズ可能なクラスのインスタンスに悪意のあるコードを挿入できると聞いたことがありますが、クラスの定義がクライアントとサーバーで同じでなければならないため、これはどのように可能ですか？

ありがとうございました！

Answer 1

FilterInputStream（http://docs.oracle.com/javase/6/docs/api/java/io/FilterInputStream.html）を書き込んで、その基本ストリームからXバイト以上のデータを読み取ると例外がスローされるのはなぜですか？

このページのreadObjectへの呼び出しを置き換えるために使用できる方法があります：

https://www.contrastsecurity.com/security-influencers/java-serialization-vulnerability-threatens-millions-of-applications

/** 
* A method to replace the unsafe ObjectInputStream.readObject() method built into Java. This method 
* checks to be sure the classes referenced are safe, the number of objects is limited to something sane, 
* and the number of bytes is limited to a reasonable number. The returned Object is also cast to the 
* specified type. 
* 
* @param type Class representing the object type expected to be returned 
* @param safeClasses List of Classes allowed in serialized object being read 
* @param maxObjects long representing the maximum number of objects allowed inside the serialized object being read 
* @param maxBytes long representing the maximum number of bytes allowed to be read from the InputStream 
* @param in InputStream containing an untrusted serialized object 
* @return Object read from the stream (cast to the Class of the type parameter) 
* @throws IOException 
* @throws ClassNotFoundException 
*/ 

@SuppressWarnings("unchecked") 
public static T safeReadObject(Class<?> type, List<Class<?>> safeClasses, long maxObjects, long maxBytes, InputStream in) throws IOException, ClassNotFoundException { 
    // create an input stream limited to a certain number of bytes 
    InputStream lis = new FilterInputStream(in) { 
     private long len = 0; 
     public int read() throws IOException { 
      int val = super.read(); 
      if (val != -1) { 
       len++; 
       checkLength(); 
      } 
      return val; 
     } 
     public int read(byte[] b, int off, int len) throws IOException { 
      int val = super.read(b, off, len); 
      if (val > 0) { 
       len += val; 
       checkLength(); 
      } 
      return val; 
     } 
     private void checkLength() throws IOException { 
      if (len > maxBytes) { 
       throw new SecurityException("Security violation: attempt to deserialize too many bytes from stream. Limit is " + maxBytes); 
      } 
     } 
    }; 
    // create an object input stream that checks classes and limits the number of objects to read 
    ObjectInputStream ois = new ObjectInputStream(lis) { 
     private int objCount = 0; 
     boolean b = enableResolveObject(true); 
     protected Object resolveObject(Object obj) throws IOException { 
      if (objCount++ > maxObjects) throw new SecurityException("Security violation: attempt to deserialize too many objects from stream. Limit is " + maxObjects); 
      Object object = super.resolveObject(obj); 
      return object; 
     } 
     protected Class<?> resolveClass(ObjectStreamClass osc) throws IOException, ClassNotFoundException { 
      Class<?> clazz = super.resolveClass(osc); 
      if (
       clazz.isArray() || 
       clazz.equals(type) || 
       clazz.equals(String.class) || 
       Number.class.isAssignableFrom(clazz) || 
       safeClasses.contains(clazz) 
      ) return clazz; 
      throw new SecurityException("Security violation: attempt to deserialize unauthorized " + clazz); 
     } 
    }; 
    // use the protected ObjectInputStream to read object safely and cast to T 
    return (T)ois.readObject(); 
}