Add vanilla parity harness and harden server boundaries

internal/protocol/frame.go

@@ -46,11 +46,11 @@ func ReadPacket(br *bufio.Reader, threshold int32) (Packet, error) {
 	if threshold < 0 {
 		return parseIDBody(frame)
 	}
-	return parseCompressed(frame)
+	return parseCompressed(frame, threshold)
 }
 
 // parseCompressed handles a frame that begins with a Data Length VarInt.
-func parseCompressed(frame []byte) (Packet, error) {
+func parseCompressed(frame []byte, threshold int32) (Packet, error) {
 	r := NewReader(frame)
 	dataLen, err := r.VarInt()
 	if err != nil {
@@ -60,22 +60,40 @@ func parseCompressed(frame []byte) (Packet, error) {
 
 	if dataLen == 0 {
 		// Stored uncompressed.
+		if len(payload) >= int(threshold) {
+			return Packet{}, ErrBadCompression
+		}
 		return parseIDBody(payload)
 	}
 	if dataLen < 0 || int(dataLen) > MaxPacketSize {
 		return Packet{}, ErrPacketTooLarge
 	}
+	if dataLen < threshold {
+		return Packet{}, ErrBadCompression
+	}
 
-	zr, err := zlib.NewReader(bytes.NewReader(payload))
+	compressed := bytes.NewReader(payload)
+	zr, err := zlib.NewReader(compressed)
 	if err != nil {
 		return Packet{}, err
 	}
-	defer zr.Close()
+	if multistream, ok := zr.(interface{ Multistream(bool) }); ok {
+		multistream.Multistream(false)
+	}
 
 	out := make([]byte, dataLen)
 	if _, err := io.ReadFull(zr, out); err != nil {
+		zr.Close()
 		return Packet{}, err
 	}
+	var extra [1]byte
+	if n, err := zr.Read(extra[:]); n != 0 || err != io.EOF {
+		zr.Close()
+		return Packet{}, ErrBadCompression
+	}
+	if err := zr.Close(); err != nil || compressed.Len() != 0 {
+		return Packet{}, ErrBadCompression
+	}
 	return parseIDBody(out)
 }
 
@@ -92,8 +110,18 @@ func parseIDBody(buf []byte) (Packet, error) {
 // WritePacket writes one frame to w with the given ID and body, using the
 // uncompressed format when threshold < 0 and the compressed format otherwise.
 func WritePacket(w io.Writer, threshold int32, id int32, body []byte) error {
-	_, err := w.Write(AppendPacket(nil, threshold, id, body))
-	return err
+	frame := AppendPacket(nil, threshold, id, body)
+	for len(frame) > 0 {
+		n, err := w.Write(frame)
+		if err != nil {
+			return err
+		}
+		if n <= 0 || n > len(frame) {
+			return io.ErrShortWrite
+		}
+		frame = frame[n:]
+	}
+	return nil
 }
 
 // AppendPacket appends one fully-framed packet to dst and returns the result.