You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@juneau.apache.org by ja...@apache.org on 2026/08/16 19:33:54 UTC

(juneau) 05/08: READY-388/391: Bound Protobuf LEN fields by maxLength and reject overlong varints

This is an automated email from the ASF dual-hosted git repository.

jamesbognar pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/juneau.git

commit 694bed1ddc02f26d5dbe9137910fbec157c7acee
Author: James Bognar <ja...@apache.org>
AuthorDate: Sun Aug 16 15:33:06 2026 -0400

    READY-388/391: Bound Protobuf LEN fields by maxLength and reject overlong varints
---
 .../juneau/marshall/protobuf/ProtobufReader.java   | 37 ++++++++++++++++---
 .../marshall/protobuf/ProtobufReader_Test.java     | 42 ++++++++++++++++++++++
 2 files changed, 75 insertions(+), 4 deletions(-)

diff --git a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/marshall/protobuf/ProtobufReader.java b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/marshall/protobuf/ProtobufReader.java
index 4d52c8662e..e7599c174a 100644
--- a/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/marshall/protobuf/ProtobufReader.java
+++ b/juneau-core/juneau-marshall/src/main/java/org/apache/juneau/marshall/protobuf/ProtobufReader.java
@@ -57,6 +57,9 @@ public class ProtobufReader {
 	/** Default cap (16 MiB) for wire-declared length-delimited block sizes. */
 	static final int DEFAULT_MAX_LENGTH = 16 * 1024 * 1024;
 
+	/** Maximum encoded length, in bytes, of a 64-bit protobuf varint (ceil(64 / 7) LEB128 groups). */
+	private static final int MAX_VARINT_BYTES = 10;
+
 	private final InputStream is;
 	private int maxLength = DEFAULT_MAX_LENGTH;
 
@@ -112,19 +115,28 @@ public class ProtobufReader {
 	/**
 	 * Reads a base-128 varint (LEB128) as a 64-bit value.
 	 *
+	 * <p>
+	 * Caps the encoding at {@value #MAX_VARINT_BYTES} bytes (the maximum a 64-bit varint can occupy), so a
+	 * malformed stream of continuation bytes cannot burn unbounded CPU/bytes before EOF.
+	 *
 	 * @return The decoded value.
-	 * @throws IOException If the stream ends mid-varint or the underlying stream fails.
+	 * @throws IOException If the stream ends mid-varint, the varint exceeds {@value #MAX_VARINT_BYTES} bytes,
+	 * 	or the underlying stream fails.
 	 */
 	public long readVarint() throws IOException {
 		var result = 0L;
 		var shift = 0;
+		var count = 0;
 		int b;
 		do {
 			b = read();
 			if (b == -1)
 				throw ioex("Unexpected end of protobuf input while reading varint");
+			count++;
 			result |= ((long)(b & 0x7F)) << shift;
 			shift += 7;
+			if (count == MAX_VARINT_BYTES && (b & 0x80) != 0)
+				throw ioex("Protobuf varint exceeds maximum length of %s bytes", MAX_VARINT_BYTES);
 		} while ((b & 0x80) != 0);
 		return result;
 	}
@@ -132,8 +144,12 @@ public class ProtobufReader {
 	/**
 	 * Reads a field tag, or returns {@link #EOF} if the stream is exhausted at a field boundary.
 	 *
+	 * <p>
+	 * Caps the encoding at {@value #MAX_VARINT_BYTES} bytes, the same bound applied by {@link #readVarint()}.
+	 *
 	 * @return The decoded tag value (<c>(fieldNumber &lt;&lt; 3) | wireType</c>), or {@link #EOF} at end of stream.
-	 * @throws IOException If the stream ends mid-tag or the underlying stream fails.
+	 * @throws IOException If the stream ends mid-tag, the tag exceeds {@value #MAX_VARINT_BYTES} bytes, or the
+	 * 	underlying stream fails.
 	 */
 	public long readTag() throws IOException {
 		var b = read();
@@ -141,12 +157,16 @@ public class ProtobufReader {
 			return EOF;
 		var result = (long)(b & 0x7F);
 		var shift = 7;
+		var count = 1;
 		while ((b & 0x80) != 0) {
 			b = read();
 			if (b == -1)
 				throw ioex("Unexpected end of protobuf input while reading tag");
+			count++;
 			result |= ((long)(b & 0x7F)) << shift;
 			shift += 7;
+			if (count == MAX_VARINT_BYTES && (b & 0x80) != 0)
+				throw ioex("Protobuf varint exceeds maximum length of %s bytes", MAX_VARINT_BYTES);
 		}
 		return result;
 	}
@@ -277,15 +297,24 @@ public class ProtobufReader {
 	/**
 	 * Skips a field's value, consuming exactly the right number of bytes for the specified wire type.
 	 *
+	 * <p>
+	 * For {@link WireType#LEN}, the wire-declared length is validated against the configured maximum (the
+	 * same check applied by {@link #readLenDelimited()}) before skipping, so an unknown forward-compatible
+	 * field cannot bypass the length cap via an unbounded or wrapped-negative skip.
+	 *
 	 * @param wireType The wire type of the field to skip.
-	 * @throws IOException If the stream ends early or the underlying stream fails.
+	 * @throws IOException If the stream ends early, the declared length is out of bounds, or the underlying
+	 * 	stream fails.
 	 */
 	public void skipField(WireType wireType) throws IOException {
 		switch (wireType) {
 			case VARINT -> readVarint();
 			case I64 -> skip(8);
 			case I32 -> skip(4);
-			case LEN -> skip((int)readVarint());
+			case LEN -> {
+				var len = ParserInputStream.checkLength(readVarint(), maxLength, "protobuf field");
+				skip(len);
+			}
 			default -> throw ioex("Cannot skip unsupported protobuf wire type: %s", wireType);
 		}
 	}
diff --git a/juneau-core/juneau-marshall/src/test/java/org/apache/juneau/marshall/protobuf/ProtobufReader_Test.java b/juneau-core/juneau-marshall/src/test/java/org/apache/juneau/marshall/protobuf/ProtobufReader_Test.java
index 13f364fa9c..cc215deb12 100644
--- a/juneau-core/juneau-marshall/src/test/java/org/apache/juneau/marshall/protobuf/ProtobufReader_Test.java
+++ b/juneau-core/juneau-marshall/src/test/java/org/apache/juneau/marshall/protobuf/ProtobufReader_Test.java
@@ -16,8 +16,11 @@
  */
 package org.apache.juneau.marshall.protobuf;
 
+import static org.apache.juneau.BasicTestUtils.*;
 import static org.junit.jupiter.api.Assertions.*;
 
+import java.io.*;
+
 import org.apache.juneau.*;
 import org.junit.jupiter.api.*;
 
@@ -111,4 +114,43 @@ class ProtobufReader_Test extends TestBase {
 		r4.skipField(WireType.LEN);
 		assertEquals(2, ProtobufReader.fieldNumber(r4.readTag()));
 	}
+
+	@Test
+	void a09_varintRejectsOverlongContinuation() throws Exception {
+		// 10 continuation bytes (0x80) with no terminating byte: the 10th byte still has the continuation
+		// bit set, so the varint never terminates within the 10-byte cap.
+		var r = reader(0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80);
+		assertThrowsWithMessage(IOException.class, "exceeds maximum length of 10 bytes", r::readVarint);
+
+		// Same shape but with an 11th byte present ("10x0x80 + more") -- still rejected at byte 10.
+		var r2 = reader(0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x01);
+		assertThrowsWithMessage(IOException.class, "exceeds maximum length of 10 bytes", r2::readVarint);
+	}
+
+	@Test
+	void a10_varintCanonicalTenByteNegativeOneStillDecodes() throws Exception {
+		// Canonical 10-byte encoding of -1L must remain valid (terminating byte on the 10th).
+		assertEquals(-1L, reader(0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0x01).readVarint());
+	}
+
+	@Test
+	void a11_tagRejectsOverlongContinuation() throws Exception {
+		var r = reader(0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80);
+		assertThrowsWithMessage(IOException.class, "exceeds maximum length of 10 bytes", r::readTag);
+	}
+
+	@Test
+	void b01_skipFieldLenRejectsLengthAboveMaxLength() throws Exception {
+		// Declared length (10) exceeds the configured maximum (5); must reject before skipping any data.
+		var r = reader(0x0A, 1,2,3,4,5,6,7,8,9,10, 0x10);
+		r.setMaxLength(5);
+		assertThrowsWithMessage(IOException.class, "exceeds maximum allowed", () -> r.skipField(WireType.LEN));
+	}
+
+	@Test
+	void b02_skipFieldLenRejectsWrappedNegativeVarint() throws Exception {
+		// Varint decodes to -1L (wrapped-negative as an int cast); must reject rather than skip a negative count.
+		var r = reader(0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0x01);
+		assertThrowsWithMessage(IOException.class, "negative", () -> r.skipField(WireType.LEN));
+	}
 }