From 16601d75a6e02f468d65991c1c7c8897a0a7ff01 Mon Sep 17 00:00:00 2001 From: Marcelo Trylesinski Date: Mon, 16 Nov 2026 10:12:55 +0100 Subject: [PATCH] Extract multipart header-size validation into a method --- python_multipart/multipart.py | 19 +++++++++--------- tests/test_multipart.py | 38 +++++++++++++++++++++++++++++++++-- 2 files changed, 46 insertions(+), 11 deletions(-) diff --git a/python_multipart/multipart.py b/python_multipart/multipart.py index 604bd70..a29c575 100644 --- a/python_multipart/multipart.py +++ b/python_multipart/multipart.py @@ -1135,6 +1135,10 @@ def write(self, data: bytes) -> int: return l + def _check_header_size(self, size: int, offset: int) -> None: + if size > self.max_header_size: + raise MultipartParseError("Maximum header size exceeded", offset=offset) + def _internal_write(self, data: bytes, length: int) -> int: # Get values from locals. boundary = self.boundary @@ -1151,12 +1155,6 @@ def _internal_write(self, data: bytes, length: int) -> int: # Our index defaults to 0. i = 0 - def advance_header_size(amount: int = 1) -> None: - nonlocal current_header_size - current_header_size += amount - if current_header_size > self.max_header_size: - raise MultipartParseError("Maximum header size exceeded", offset=i) - # Helper function that makes calling a callback with data easier. The # 'remaining' parameter will callback from the marked value until the # end of the buffer, and reset the mark, instead of deleting it. This @@ -1312,7 +1310,8 @@ def data_callback(name: CallbackName, end_i: int, remaining: bool = False) -> No # Enforce the size limit before slicing and validating, so an oversized header # name fails fast instead of copying and scanning a potentially huge span. - advance_header_size(end - i if colon == -1 else end - i + 1) + current_header_size += end - i if colon == -1 else end - i + 1 + self._check_header_size(current_header_size, i) field = data[i:end] if field.translate(None, TOKEN_CHARS): @@ -1343,7 +1342,8 @@ def data_callback(name: CallbackName, end_i: int, remaining: bool = False) -> No elif state == HEADER_VALUE_START: # Skip leading spaces. if c == SPACE: - advance_header_size() + current_header_size += 1 + self._check_header_size(current_header_size, i) i += 1 continue @@ -1359,7 +1359,8 @@ def data_callback(name: CallbackName, end_i: int, remaining: bool = False) -> No # instead of inspecting every byte. cr = data.find(b"\r", i, length) end = cr if cr != -1 else length - advance_header_size(end - i) + current_header_size += end - i + self._check_header_size(current_header_size, i) if cr != -1: i = cr data_callback("header_value", i) diff --git a/tests/test_multipart.py b/tests/test_multipart.py index 31b84e3..8b9f66b 100644 --- a/tests/test_multipart.py +++ b/tests/test_multipart.py @@ -913,6 +913,39 @@ def test_multipart_opening_boundary_max_size() -> None: assert events == ["begin", "end"] +@pytest.mark.parametrize( + "header,limit,offset", + [ + (b"Long: value", 4, 0), + (b"Long@: value", 4, 0), + (b"X: value", 4, 4), + (b"X: value", 7, 3), + (b"Long: value", 11, None), + (b"X: value", 12, None), + (b"X: value", 8, None), + ], +) +@pytest.mark.parametrize("split", [0, 4]) +def test_multipart_header_size_limit_offsets(header: bytes, limit: int, offset: int | None, split: int) -> None: + events: list[str] = [] + parser = MultipartParser( + b"b", + {"on_header_end": lambda: events.append("header_end"), "on_end": lambda: events.append("end")}, + max_header_size=limit, + ) + parser.write(b"--b\r\n" + header[:split]) + remaining = header[split:] + b"\r\n\r\nbody\r\n--b--\r\n" + if offset is not None: + with pytest.raises(MultipartParseError, match="Maximum header size exceeded") as exc: + parser.write(remaining) + assert exc.value.offset == (0 if split else offset) + assert events == [] + else: + assert parser.write(remaining) == len(remaining) + parser.finalize() + assert events == ["header_end", "end"] + + @pytest.mark.parametrize( "config,first,second,message", [ @@ -1360,9 +1393,10 @@ def test_multipart_header_count_limit(self) -> None: with self.assertRaisesRegex(MultipartParseError, "Maximum header count exceeded"): self.f.write(payload) - def test_multipart_header_size_limit(self) -> None: + @parametrize("header", [b"X-A: " + b"a" * 4220, b"X-" + b"a" * 4224, b"X-A:" + b" " * 4224]) + def test_multipart_header_size_limit(self, header: bytes) -> None: self.make("poc") - payload = b'--poc\r\nContent-Disposition: form-data; name="x"\r\n' + b"X-A: " + (b"a" * (4096 + 124)) + payload = b'--poc\r\nContent-Disposition: form-data; name="x"\r\n' + header with self.assertRaisesRegex(MultipartParseError, "Maximum header size exceeded"): self.f.write(payload)