Patched code sample

import sys
from restrictedpython.compiler import compile_restricted
from restrictedpython.Guards import (
    safe_builtins,
    full_write_guard,
    safer_getattr,
    guarded_iter_unpack_sequence,
    GuardedPrintCollector,
)

def execute_sandboxed_code_fixed(user_code: str, items_data: list):
    """
    This function demonstrates the patched code execution logic. The fix for
    the vulnerability involves creating a more restrictive global environment
    for the sandboxed code, primarily by replacing the standard `getattr`
    function with `restrictedpython.Guards.safer_getattr`.

    `safer_getattr` blocks access to attributes starting with an underscore '_',
    which prevents attackers from traversing an object's hierarchy (e.g., via
    `__class__`, `__base__`, `__subclasses__`, `__globals__`) to reach and
    execute dangerous functions, thus preventing the sandbox escape.
    """

    # The `restricted_globals` dictionary is the core of the fix.
    # It defines the secure environment in which the user's code will run.
    restricted_globals = {
        "__builtins__": {
            **safe_builtins,
            #
            # --- START OF THE FIX ---
            #
            # The vulnerable version used a more permissive `getattr`. Replacing
            # it with `safer_getattr` is the primary mitigation.
            "getattr": safer_getattr,
            #
            # These additional guards further harden the execution environment.
            "_getiter_": guarded_iter_unpack_sequence,
            "_iter_unpack_sequence_": guarded_iter_unpack_sequence,
            #
            # ---  END OF THE FIX  ---
            #
            "print": GuardedPrintCollector,
        },
        "_write_": full_write_guard,
        "_print_": GuardedPrintCollector,
        "items": items_data,
    }

    try:
        # Compile the user code in the restricted mode.
        byte_code = compile_restricted(
            user_code,
            filename='<user_code>',
            mode='exec'
        )

        # Execute the compiled code within the secured global scope.
        exec(byte_code, restricted_globals)

    except Exception as e:
        # In a real application, errors would be handled and logged.
        # For this demonstration, we re-raise the exception.
        raise e

    # In the actual application, the results (e.g., modified 'items' and
    # captured print output) would be processed and returned.
    return {
        "result": restricted_globals.get("items"),
        "printed_output": restricted_globals["_print_"](),
    }