Patched code sample

import sys
from io import StringIO

def safe_eval(user_script: str):
    """
    Executes a user-supplied script in a restricted environment to prevent
    command injection. This is the fixed version of the function that addresses
    the vulnerability described in CVE-2025-63603.

    The fix involves explicitly defining the 'globals' dictionary for exec()
    and providing a restricted or empty '__builtins__' dictionary. By setting
    '__builtins__' to a controlled dictionary, we remove access to dangerous
    functions like '__import__', 'open', 'eval', and 'exec', effectively
    mitigating the command injection vulnerability.
    """
    
    # A whitelist of safe built-in functions can be provided.
    # For a truly minimal environment, this can be an empty dictionary: {}.
    # Here, we allow 'print' for demonstration purposes, but nothing dangerous.
    safe_builtins = {
        'print': print,
        'len': len,
        'abs': abs,
        'str': str,
        'int': int,
        'float': float,
        'list': list,
        'dict': dict,
        'set': set,
        'range': range,
    }

    safe_globals = {
        "__builtins__": safe_builtins,
    }

    # The 'locals' dictionary can be used to retrieve results from the script.
    safe_locals = {}
    
    # Redirect stdout to capture print statements from the executed script
    old_stdout = sys.stdout
    redirected_output = sys.stdout = StringIO()

    try:
        # Execute the user script within the sandboxed environment.
        exec(user_script, safe_globals, safe_locals)
        sys.stdout = old_stdout # Restore stdout
        output = redirected_output.getvalue()
        
        # Remove the result of the last expression if it's None (common with print)
        if '__result__' in safe_locals and safe_locals['__result__'] is None:
            del safe_locals['__result__']

        return {"success": True, "output": output, "locals": safe_locals}
    except Exception as e:
        sys.stdout = old_stdout # Restore stdout on error
        # Catch exceptions from the user's script to prevent server crashes.
        return {"success": False, "error": str(e)}


if __name__ == '__main__':
    # This demonstration code would not be part of the actual server.py,
    # but is included here to show how the fix works.

    # --- 1. Malicious Payload (as described in the CVE) ---
    # This script attempts to use __import__ to run an OS command.
    # In the vulnerable version, this would execute.
    malicious_script = "__import__('os').system('echo VULNERABILITY EXPLOITED')"
    
    print("--- [DEMO 1] Attempting to execute malicious script with the FIXED safe_eval ---")
    result = safe_eval(malicious_script)

    if not result['success']:
        print("Execution FAILED as expected.")
        print(f"Error returned: {result['error']}")
        if "name '__import__' is not defined" in result['error']:
            print("\n[SUCCESS] The fix is effective. The script was blocked from accessing '__import__'.\n")
        else:
            print("\n[NOTE] The script failed, but check the error to ensure it's for the right reason.\n")
    else:
        print("\n[FAILURE] The vulnerability appears to still exist. The malicious script executed.\n")

    print("="*70)

    # --- 2. Benign Payload ---
    # This script uses only the whitelisted 'print' function and performs basic arithmetic.
    # This should execute successfully.
    benign_script = "a = 10\nb = 20\nresult = a + b\nprint(f'The result is {result}')"

    print("\n--- [DEMO 2] Attempting to execute a benign script ---")
    result_benign = safe_eval(benign_script)
    
    if result_benign['success']:
        print("Execution SUCCEEDED as expected.")
        print(f"Script output:\n---\n{result_benign['output'].strip()}\n---")
        print(f"Returned local variables: {result_benign['locals']}")
        print("\n[SUCCESS] The fix correctly allows safe operations while blocking dangerous ones.\n")
    else:
        print(f"\n[FAILURE] The benign script failed unexpectedly. Error: {result_benign.get('error')}\n")