Patched code sample

import ast
import io
from contextlib import redirect_stdout

# Since CVE-2025-12695 is a fictional CVE, this code represents a
# hypothetical fix for the described vulnerability. The vulnerability involves
# a Python interpreter class that unsafely executes user-provided code,
# allowing file system access.
#
# The fix demonstrates a sandboxing approach using Python's Abstract Syntax Tree (AST)
# to validate the code before execution. It disallows dangerous operations
# like imports, file access, and calls to unsafe built-in functions.

class PatchedPythonInterpreter:
    """
    A Python interpreter that safely executes code by validating it against
    a whitelist of allowed operations using an Abstract Syntax Tree (AST) walk.
    """

    def __init__(self):
        # A whitelist of safe built-in function names.
        # Functions like 'open', 'eval', 'exec', '__import__' are deliberately excluded.
        self.safe_builtins = {
            'print', 'len', 'str', 'int', 'float', 'list', 'dict', 'tuple',
            'range', 'abs', 'sum', 'min', 'max', 'round', 'pow', 'sorted'
        }
        # A whitelist of safe modules, if any were to be allowed. Kept empty for max security.
        self.safe_modules = {}

    def _validate_ast(self, code_string: str):
        """
        Parses the code into an AST and walks through it to ensure no
        disallowed operations are present.

        Args:
            code_string: The Python code to validate.

        Raises:
            SecurityError: If an unsafe operation is detected.
        """
        try:
            tree = ast.parse(code_string)
        except SyntaxError as e:
            raise SecurityError(f"Invalid Python syntax: {e}") from e

        for node in ast.walk(tree):
            # 1. Disallow imports
            if isinstance(node, (ast.Import, ast.ImportFrom)):
                raise SecurityError("Imports are strictly forbidden.")

            # 2. Disallow attribute access that starts with an underscore
            if isinstance(node, ast.Attribute) and node.attr.startswith('_'):
                raise SecurityError("Access to private/magic attributes (e.g., __class__) is forbidden.")

            # 3. Validate all function calls
            if isinstance(node, ast.Call):
                if isinstance(node.func, ast.Name):
                    # It's a direct function call, like print() or open()
                    func_name = node.func.id
                    if func_name not in self.safe_builtins:
                        raise SecurityError(f"Call to disallowed function '{func_name}' is forbidden.")
                elif isinstance(node.func, ast.Attribute):
                    # It's a method call, like 'str'.upper() or obj.__dict__()
                    # For this example, we disallow all method calls for simplicity,
                    # but a more complex system could whitelist specific safe methods.
                    raise SecurityError("Method calls are forbidden in this sandbox.")

    def execute(self, code_string: str) -> str:
        """
        Executes a string of Python code after validating its safety.

        Args:
            code_string: The user-provided Python code.

        Returns:
            A string containing the standard output of the executed code or an error message.
        """
        try:
            # Step 1: Validate the code's structure for safety.
            self._validate_ast(code_string)

            # Step 2: Prepare a safe, restricted environment for execution.
            # The '__builtins__' dictionary is carefully constructed to only
            # expose the whitelisted safe functions.
            safe_globals = {
                "__builtins__": {
                    name: __builtins__[name] for name in self.safe_builtins
                }
            }

            # Step 3: Execute the validated code and capture its output.
            output_capture = io.StringIO()
            with redirect_stdout(output_capture):
                exec(code_string, safe_globals, {})
            
            return output_capture.getvalue()

        except (SecurityError, Exception) as e:
            return f"Execution blocked or failed: {e}"


class SecurityError(Exception):
    """Custom exception for security-related validation failures."""
    pass


if __name__ == '__main__':
    # Demonstration of the fix
    interpreter = PatchedPythonInterpreter()

    print("--- Demonstrating the Patched (Fixed) Interpreter ---")

    # --- Attack Attempts (Should be blocked) ---

    # 1. Attempt to read a sensitive file using `open()`
    malicious_code_file_read = "print(open('/etc/passwd', 'r').read())"
    print(f"\nExecuting malicious code: {malicious_code_file_read}")
    result = interpreter.execute(malicious_code_file_read)
    print(f"Result: {result}")

    # 2. Attempt to list directories using the `os` module
    malicious_code_import_os = "import os; print(os.listdir('/'))"
    print(f"\nExecuting malicious code: {malicious_code_import_os}")
    result = interpreter.execute(malicious_code_import_os)
    print(f"Result: {result}")

    # 3. Attempt to use `__import__` to bypass import block
    malicious_code_dunder_import = "__import__('os').system('echo vulnerable')"
    print(f"\nExecuting malicious code: {malicious_code_dunder_import}")
    result = interpreter.execute(malicious_code_dunder_import)
    print(f"Result: {result}")
    
    # 4. Attempt to escape the sandbox via `__class__`
    malicious_code_escape = "print(''.__class__.__mro__[1].__subclasses__())"
    print(f"\nExecuting malicious code: {malicious_code_escape}")
    result = interpreter.execute(malicious_code_escape)
    print(f"Result: {result}")

    # --- Benign Code (Should be allowed) ---

    # 5. Simple arithmetic and printing
    safe_code = """
a = 15
b = 30
result = a * 2 + b
print(f"The result is: {result}")
"""
    print(f"\nExecuting safe code: {safe_code.strip()}")
    result = interpreter.execute(safe_code)
    print(f"Result:\n{result}")

    # 6. Using an allowed built-in function `len()`
    safe_code_len = "print(len('this is a safe string'))"
    print(f"\nExecuting safe code: {safe_code_len}")
    result = interpreter.execute(safe_code_len)
    print(f"Result: {result}")