diff --git a/can/io/blf.py b/can/io/blf.py index 86c0f72a7..456b0e4db 100644 --- a/can/io/blf.py +++ b/can/io/blf.py @@ -229,6 +229,13 @@ def _parse_data(self, data: bytes) -> Iterator[Message]: unpack_can_fd_64_msg = CAN_FD_MSG_64_STRUCT.unpack_from can_fd_64_msg_size = CAN_FD_MSG_64_STRUCT.size unpack_can_error_ext = CAN_ERROR_EXT_STRUCT.unpack_from + payload_sizes = { + CAN_MESSAGE: CAN_MSG_STRUCT.size, + CAN_MESSAGE2: CAN_MSG_STRUCT.size, + CAN_ERROR_EXT: CAN_ERROR_EXT_STRUCT.size, + CAN_FD_MESSAGE: CAN_FD_MSG_STRUCT.size, + CAN_FD_MESSAGE_64: can_fd_64_msg_size, + } start_timestamp = self.start_timestamp max_pos = len(data) @@ -260,6 +267,22 @@ def _parse_data(self, data: bytes) -> Iterator[Message]: return pos += obj_header_base_size + if header_version in (1, 2): + minimum_size = ( + obj_header_base_size + + ( + obj_header_v1_size + if header_version == 1 + else obj_header_v2_size + ) + + payload_sizes.get(obj_type, 0) + ) + if obj_size < minimum_size: + raise BLFParseError( + f"Invalid object size {obj_size} for type {obj_type} " + f"(minimum {minimum_size})" + ) + # Read rest of header if header_version == 1: flags, _, _, timestamp = unpack_obj_header_v1(data, pos) diff --git a/doc/changelog.d/+blf-object-bounds.fixed.rst b/doc/changelog.d/+blf-object-bounds.fixed.rst new file mode 100644 index 000000000..f55f216ba --- /dev/null +++ b/doc/changelog.d/+blf-object-bounds.fixed.rst @@ -0,0 +1,2 @@ +Reject BLF objects with incomplete headers or message payloads before reading +bytes from the following object as CAN message data. diff --git a/test/logformats_test.py b/test/logformats_test.py index beb5b7b9f..02cae45db 100644 --- a/test/logformats_test.py +++ b/test/logformats_test.py @@ -885,6 +885,109 @@ def test_object_split_between_containers(self): with can.BLFReader(self.test_file_name) as reader: self.assertMessagesEqual(messages, list(reader)) + def _prepend_blf_object(self, header_version, obj_type, obj_size): + with can.BLFWriter(self.test_file_name, compression_level=0) as writer: + writer(can.Message(arbitration_id=0x456, data=range(8))) + + data = bytearray(Path(self.test_file_name).read_bytes()) + container_offset = blf.FILE_HEADER_SIZE + blf.OBJ_HEADER_BASE_STRUCT.size + offset = container_offset + blf.LOG_CONTAINER_STRUCT.size + header_size = blf.OBJ_HEADER_BASE_STRUCT.size + ( + blf.OBJ_HEADER_V2_STRUCT.size + if header_version == 2 + else blf.OBJ_HEADER_V1_STRUCT.size + ) + obj = blf.OBJ_HEADER_BASE_STRUCT.pack( + b"LOBJ", header_size, header_version, obj_size, obj_type + ) + bytes(obj_size - blf.OBJ_HEADER_BASE_STRUCT.size) + padding = bytes(obj_size % 4) + data[offset:offset] = obj + padding + added_size = len(obj) + len(padding) + container = list( + blf.OBJ_HEADER_BASE_STRUCT.unpack_from(data, blf.FILE_HEADER_SIZE) + ) + container[3] += added_size + blf.OBJ_HEADER_BASE_STRUCT.pack_into(data, blf.FILE_HEADER_SIZE, *container) + method, size = blf.LOG_CONTAINER_STRUCT.unpack_from(data, container_offset) + blf.LOG_CONTAINER_STRUCT.pack_into( + data, container_offset, method, size + added_size + ) + file_header = list(blf.FILE_HEADER_STRUCT.unpack_from(data)) + file_header[10] += added_size + file_header[11] += added_size + file_header[12] += 1 + blf.FILE_HEADER_STRUCT.pack_into(data, 0, *file_header) + return BytesIO(data) + + @parameterized.expand( + (version, obj_type, payload.size) + for version in (1, 2) + for obj_type, payload in ( + (blf.CAN_MESSAGE, blf.CAN_MSG_STRUCT), + (blf.CAN_MESSAGE2, blf.CAN_MSG_STRUCT), + (blf.CAN_ERROR_EXT, blf.CAN_ERROR_EXT_STRUCT), + (blf.CAN_FD_MESSAGE, blf.CAN_FD_MSG_STRUCT), + (blf.CAN_FD_MESSAGE_64, blf.CAN_FD_MSG_64_STRUCT), + ) + ) + def test_truncated_object_payload(self, version, obj_type, payload_size): + header_size = blf.OBJ_HEADER_BASE_STRUCT.size + ( + blf.OBJ_HEADER_V1_STRUCT.size + if version == 1 + else blf.OBJ_HEADER_V2_STRUCT.size + ) + # The next object's bytes must not complete this object's payload. + obj_size = header_size + payload_size - 4 + with can.BLFReader( + self._prepend_blf_object(version, obj_type, obj_size) + ) as reader: + with self.assertRaisesRegex(blf.BLFParseError, "Invalid object size"): + next(iter(reader)) + + @parameterized.expand( + (version, obj_type, payload.size) + for version in (1, 2) + for obj_type, payload in ( + (blf.CAN_MESSAGE, blf.CAN_MSG_STRUCT), + (blf.CAN_MESSAGE2, blf.CAN_MSG_STRUCT), + (blf.CAN_ERROR_EXT, blf.CAN_ERROR_EXT_STRUCT), + (blf.CAN_FD_MESSAGE, blf.CAN_FD_MSG_STRUCT), + (blf.CAN_FD_MESSAGE_64, blf.CAN_FD_MSG_64_STRUCT), + ) + ) + def test_minimum_object_payload(self, version, obj_type, payload_size): + header_size = blf.OBJ_HEADER_BASE_STRUCT.size + ( + blf.OBJ_HEADER_V1_STRUCT.size + if version == 1 + else blf.OBJ_HEADER_V2_STRUCT.size + ) + with can.BLFReader( + self._prepend_blf_object(version, obj_type, header_size + payload_size) + ) as reader: + messages = list(reader) + self.assertEqual(len(messages), 2) + self.assertEqual(messages[0].data, bytearray()) + self.assertEqual(messages[1].arbitration_id, 0x456) + self.assertEqual(messages[1].data, bytearray(range(8))) + + @parameterized.expand([(1, 28), (2, 36)]) + def test_truncated_object_header(self, version, obj_size): + with can.BLFReader( + self._prepend_blf_object(version, blf.CAN_MESSAGE, obj_size) + ) as reader: + with self.assertRaisesRegex(blf.BLFParseError, "Invalid object size"): + next(iter(reader)) + + @parameterized.expand([(3, blf.CAN_MESSAGE, 32), (1, 0xFFFF, 32)]) + def test_skip_unknown_object(self, version, obj_type, obj_size): + with can.BLFReader( + self._prepend_blf_object(version, obj_type, obj_size) + ) as reader: + messages = list(reader) + self.assertEqual(len(messages), 1) + self.assertEqual(messages[0].arbitration_id, 0x456) + self.assertEqual(messages[0].data, bytearray(range(8))) + def test_can_message(self): expected = can.Message( timestamp=2459565876.494607,