Patched code sample

import sys
import io

def fixed_python_task_executor(user_code: str):
    """
    Demonstrates the fix for a sandbox escape vulnerability by safely handling
    exceptions raised from user-provided code.

    The original vulnerability (similar to CVE-2023-0863) occurred when the
    exception handler used unsafe string formatting (like f-strings or '%s')
    on an exception object. An attacker could craft a custom exception
    with a malicious __str__ method. When the handler tried to log the
    exception, it would execute the malicious __str__ method outside the
    sandbox's restrictions.

    The fix is to avoid any operation that would implicitly call the
    exception's __str__ or __repr__ methods. Instead, we safely access
    well-defined, non-overridable attributes of the exception object,
    such as its class name and arguments tuple.
    """
    # Simulate a restricted environment for the user code execution.
    # In a real scenario, this would be more complex, but for demonstration,
    # we'll just restrict the built-in functions available.
    restricted_globals = {
        "__builtins__": {
            "Exception": Exception,
            "print": print,
        }
    }
    
    # Redirect stdout to capture output from the sandboxed code
    old_stdout = sys.stdout
    sys.stdout = captured_output = io.StringIO()

    try:
        # Execute the untrusted user code in the restricted scope
        exec(user_code, restricted_globals)
    except Exception as e:
        # --- FIX IMPLEMENTATION ---
        # Instead of using a format that calls the object's __str__ method,
        # we build a safe string representation manually.
        #
        # VULNERABLE (OLD) CODE would look like this:
        #
        #   print(f"An error occurred: {e}", file=sys.stderr)
        #   # OR
        #   print("An error occurred: %s" % e, file=sys.stderr)
        #
        # FIXED (NEW) CODE:
        # Safely get the exception's class name and its arguments.
        # e.__class__.__name__ is a string and cannot be overridden by the user code.
        # e.args is a tuple of the arguments passed to the exception constructor.
        # We use repr() on the args tuple to get a safe, printable representation.
        safe_error_message = f"An error occurred: {e.__class__.__name__}{repr(e.args)}"
        print(safe_error_message, file=sys.stderr)
    finally:
        # Restore stdout
        sys.stdout = old_stdout

    return captured_output.getvalue()


if __name__ == '__main__':
    # This is the malicious code an attacker would provide.
    # It defines a custom exception where the __str__ method contains
    # arbitrary code to be executed (here, a simple print statement
    # that uses a non-whitelisted built-in like `__import__`).
    attacker_code = """
class MaliciousException(Exception):
    def __str__(self):
        # This payload would run in the vulnerable version upon exception logging.
        # It attempts to use a forbidden function to prove escape.
        __import__('os').system('echo PWNED: Sandbox escaped!')
        return "Payload executed"

# Raise the custom exception to trigger the vulnerable handler
raise MaliciousException("trigger")
"""

    print("--- Running code with the FIXED executor ---")
    print("The fix prevents the malicious __str__ method from being called.")
    print("We expect to see a safe error message, NOT 'PWNED'.")
    print("-" * 40)
    
    # The output will be printed to stderr by the handler.
    # The return value will be empty as no standard 'print' was called.
    output = fixed_python_task_executor(attacker_code)
    
    print("-" * 40)
    print(f"Captured stdout from sandboxed code: {repr(output)}")
    print("Execution finished. If 'PWNED' was not printed, the fix is effective.")