Patched code sample

import pickle
import logging
from pickle import UnpicklingError

# A simplified set of classes considered safe to unpickle. The vulnerability
# is not about which classes are imported, but the arguments passed to them.
SAFE_TO_IMPORT = {
    'deepdiff.delta.Delta',
    'deepdiff.helper.NotPresent',
    'collections.OrderedDict',
    'datetime.date',
    'datetime.datetime',
    'datetime.time',
    'datetime.timedelta',
    'builtins.bytes',
    'builtins.list',
    'builtins.range',
}

# The maximum size allowed for constructor arguments of certain built-in types
# to prevent denial-of-service attacks via memory allocation. This is the core
# of the fix's strategy.
MAX_UNPICKLE_ARG_SIZE = 4096

# A mapping of built-in types that are subject to argument size limitation.
LIMITED_BUILTINS = {
    bytes: MAX_UNPICKLE_ARG_SIZE,
    list: MAX_UNPICKLE_ARG_SIZE,
    range: MAX_UNPICKLE_ARG_SIZE,
}

log = logging.getLogger()


class _RestrictedUnpickler(pickle.Unpickler):
    """
    A restricted unpickler that prevents loading of arbitrary classes and
    protects against memory exhaustion attacks by limiting constructor arguments
    for certain built-in types.
    """
    def find_class(self, module, name):
        """
        The original security mechanism: only allow importing from a safe list.
        """
        if f"{module}.{name}" in SAFE_TO_IMPORT:
            return super().find_class(module, name)

        # Forbid everything else.
        raise UnpicklingError(
            f"Global '{module}.{name}' is forbidden to be unpickled. "
            "If you really trust this pickle, you can add it to "
            "deepdiff.pickle.SAFE_TO_IMPORT."
        )

    # THE FIX: This method is overridden to check constructor arguments.
    def load_build(self):
        """
        This method is called by the pickle BUILD opcode to set the state of a
        newly created object. We override it to inspect and validate the
        constructor arguments before the object is actually built, preventing
        the memory allocation vulnerability.
        """
        # Peek at the object's class and its constructor arguments from the stack.
        stack = self.stack
        state = stack.pop()
        cls = stack[-1]

        # Check if the class is one of the types we need to limit.
        if cls in LIMITED_BUILTINS:
            limit = LIMITED_BUILTINS[cls]
            # The arguments for constructors like list(iterable) or bytes(int)
            # are passed in a tuple.
            if isinstance(state, tuple):
                # Check each argument in the constructor call.
                for arg in state:
                    # If an integer argument exceeds our defined limit, it's a
                    # potential denial-of-service attack.
                    if isinstance(arg, int) and arg > limit:
                        raise UnpicklingError(
                            f"Forbidden to unpickle {cls} with an argument "
                            f"of size {arg} > {limit} to prevent a "
                            "denial of service attack."
                        )

        # If all checks pass, put the state back on the stack and call the
        # original, C-optimized load_build from the parent class to proceed
        # with object construction.
        stack.append(state)
        super().load_build()