Patched code sample

import subprocess

def execute_sandboxed_python_code(user_code: str):
    """
    Executes user-provided Python code in a restricted, sandboxed environment
    to prevent access to the underlying host system.

    This represents a conceptual fix for a sandbox escape vulnerability. Instead
    of executing code in the main process's context, it delegates the execution
    to a separate, isolated process with heavily restricted permissions.

    In a real-world scenario like the one described for n8n, this would be
    implemented using technologies like containers (e.g., Docker) or dedicated
    sandboxing libraries that virtualize the filesystem and network, and
    strictly control system call access.

    This simplified example uses a separate Python process and a safelist
    of allowed modules to illustrate the principle of isolation.
    """
    # Define a safelist of modules that are considered safe for user code to import.
    # Crucially, modules like 'os', 'sys', 'subprocess', 'shutil', etc., are excluded.
    allowed_modules = [
        "math",
        "random",
        "datetime",
        "json",
        "re",
        "collections",
        "itertools"
    ]

    # This is the code that will be run in the isolated subprocess.
    # It sets up a restricted global environment before executing the user's code.
    runner_script = f"""
import sys

# 1. Purge all potentially dangerous built-in functions
#    Only a minimal, safe set of built-ins should be exposed.
SAFE_BUILTINS = {{
    'print', 'len', 'range', 'str', 'int', 'float', 'list', 'dict', 'set',
    'tuple', 'abs', 'round', 'max', 'min', 'sum', 'sorted', 'zip', 'enumerate',
    'bool', 'None', 'True', 'False', 'Exception'
}}
for builtin_name in list(vars(__builtins__).keys()):
    if builtin_name not in SAFE_BUILTINS:
        del __builtins__.__dict__[builtin_name]

# 2. Create a restricted global scope for the exec call.
#    Start with only the safe built-ins.
restricted_globals = {{"__builtins__": __builtins__}}

# 3. Hijack the import mechanism to enforce the module safelist.
original_import = __builtins__.__import__
allowed_modules = {allowed_modules!r}

def secure_importer(name, globals=None, locals=None, fromlist=(), level=0):
    if name not in allowed_modules:
        raise ImportError(f"Module '{{name}}' is not allowed.")
    return original_import(name, globals, locals, fromlist, level)

__builtins__.__import__ = secure_importer

# 4. Execute the user code within this heavily restricted environment.
#    Any attempt to import 'os' or 'subprocess' will be blocked by secure_importer.
#    Any attempt to use a disallowed built-in will fail.
try:
    user_code = {user_code!r}
    exec(user_code, restricted_globals)
except Exception as e:
    print(f"Execution Error: {{e}}", file=sys.stderr)

"""

    try:
        # Execute the runner script in a new, separate Python process.
        # This provides OS-level process isolation.
        # Timeout prevents long-running, malicious code (e.g., infinite loops).
        completed_process = subprocess.run(
            [sys.executable, "-c", runner_script],
            capture_output=True,
            text=True,
            timeout=5  # Set a 5-second timeout for execution.
        )

        if completed_process.returncode == 0:
            print("Execution successful. Output:")
            print(completed_process.stdout)
        else:
            print("Execution failed. Error:")
            print(completed_process.stderr)

    except subprocess.TimeoutExpired:
        print("Execution failed: Code execution timed out after 5 seconds.")
    except Exception as e:
        print(f"An unexpected error occurred during sandboxed execution: {e}")

# Example Usage:

# --- Malicious Code Attempt ---
# This code attempts to use the 'os' module to list files, which is a classic
# sandbox escape vector. The fix will prevent this.
malicious_code = """
import os
print(os.listdir('/'))
"""
print("--- Attempting to execute malicious code ---")
execute_sandboxed_python_code(malicious_code)
# Expected Output: Execution failed. Error: Execution Error: Module 'os' is not allowed.

print("\n" + "="*50 + "\n")

# --- Benign Code ---
# This code uses only allowed modules and built-ins.
benign_code = """
import random
import json

items = [random.randint(1, 100) for _ in range(5)]
output = {"result": sorted(items)}
print(json.dumps(output))
"""
print("--- Attempting to execute benign code ---")
execute_sandboxed_python_code(benign_code)
# Expected Output: Execution successful with a JSON string of sorted random numbers.