Patched code sample

import numbers

class FixedOneFlowTensor:
    """
    A mock Tensor class representing a fixed version of a OneFlow tensor.
    The fix for the described vulnerability is implemented in the __add__ method.
    """
    def __init__(self, data):
        if not isinstance(data, list) or not all(isinstance(x, numbers.Number) for x in data):
            raise TypeError("Tensor data must be a list of numbers.")
        self.data = data
        self.shape = (len(data),)

    def __repr__(self):
        return f"FixedOneFlowTensor({self.data})"

    def __add__(self, other):
        """
        This method demonstrates the fix for CVE-2025-63397.

        The vulnerability was improper input validation. The fix involves
        explicitly checking for Python sequences and converting them to a
        tensor object before they can be passed to the underlying
        native code responsible for the operation.
        """
        processed_other = None

        # --- START OF THE FIX ---
        if isinstance(other, (list, tuple)):
            # 1. VALIDATION: Identify if the operand is a Python sequence.
            #    This check was missing in the vulnerable version.
            try:
                # 2. TYPE CONVERSION: Convert the sequence to a tensor object.
                #    This ensures the native code receives a valid, expected type.
                processed_other = FixedOneFlowTensor(list(other))
            except TypeError as e:
                raise TypeError(f"Could not convert sequence to Tensor: {e}")
        elif isinstance(other, FixedOneFlowTensor):
            # If it's already a tensor, use it directly.
            processed_other = other
        else:
            # 3. FAIL-SAFE: Raise a clean Python error for other unsupported types
            #    instead of allowing a pass-through that would cause a crash.
            raise TypeError(
                f"Unsupported operand type(s) for +: 'FixedOneFlowTensor' and '{type(other).__name__}'"
            )
        # --- END OF THE FIX ---

        # The following represents the native operation that would now safely execute.
        if self.shape != processed_other.shape:
            # This simulates a broadcasting error check in the native code.
            raise ValueError(f"Shape mismatch: {self.shape} vs {processed_other.shape}")

        result_data = [x + y for x, y in zip(self.data, processed_other.data)]
        return FixedOneFlowTensor(result_data)


# --- Demonstration of the fixed code in action ---

# 1. A tensor object representing a native data structure in OneFlow.
tensor_object = FixedOneFlowTensor([100, 200, 300])

# 2. A standard Python list. In the vulnerable version, using this in an
#    operation would pass it directly to native code, causing a segfault.
python_sequence = [1, 2, 3]

# 3. With the fix, the __add__ method correctly validates and converts the
#    'python_sequence' into a 'FixedOneFlowTensor' before the operation.
#    The code now executes safely without crashing.
result = tensor_object + python_sequence

# The 'result' is a valid tensor, proving the fix was successful.
# To see the output, you could uncomment the following line:
# print(result)